day05-java-（循环问题，数组）　　　　

1.三种循环结构的更佳适用情况:
  1)while: "当..."循环
  2)do...while: "直到..."循环
                要素1与要素3相同时首选
  3)for:固定次数循环

循环结构的选择:
1.先看固定次数还是不固定次数:
    固定次数-----首选for
    不固定次数-----再看要素1与3是否相同
        要素1与要素3相同时-----首选do...while
        要素1与要素3不同时-----首选while

2.嵌套循环:
  1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
  2)执行过程:外层循环走一次，内层循环走所有次
  3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层
         若需求必须要通过三层以上循环才能解决，说明设计有问题
  4)break只能跳出一层循环

3.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的数据结构会导致好的算法

4.数组:
  1)相同数据类型元素的集合
  2)数组是一种数据类型(引用类型)
  3)数组的定义:
      int[] arr = new int[4];
  4)数组的初始化:
      int[] arr = new int[4]; //0,0,0,0
      int[] arr = {1,3,5,7};  //1,3,5,7
      int[] arr = new int[]{1,3,5,7}; //1,3,5,7
      int[] arr;
      arr = {1,3,5,7}; //编译错误
      arr = new int[]{1,3,5,7}; //正确
      
    //声明浮点型数组d，包含8个元素
    //每个元素都是double型，默认值为0.0
    double[] d = new double[8];

//声明布尔型数组b，包含26个元素
    //每个元素都是boolean型，默认值为false
    boolean[] b = new boolean[26];

//声明整型数组a，包含4个元素
    //每个元素都是int类型，默认值为0
    int[] a = new int[4]; //0,0,0,0
    
  5)数组的访问:
    5.1)通过(数组名.length)可以获取数组的长度
          int[] arr = new int[4];
          System.out.println(arr.length); //4
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到(数组的长度-1)
          int[] arr = new int[3];
          arr[0] = 100; //给arr中第1个元素赋值为100
          arr[1] = 200; //给arr中第2个元素赋值为200
          arr[2] = 300; //给arr中第3个元素赋值为300
          arr[3] = 400; //数组下标越界异常
          System.out.println(arr[arr.length-1]); //输出最后一个元素的值

6)数组的遍历:
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
        arr[i] = 100;
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }

7)数组的复制:
    7.1)System.arraycopy(a,1,a1,0,4);
    7.2)int[] a1 = Arrays.copyOf(a,6);
        a = Arrays.copyOf(a,a.length+1); //扩容
        a = Arrays.copyOf(a,a.length-1); //缩容

8)数组的排序:
    8.1)Arrays.sort(arr); //升序
    8.2)冒泡原理:
        8.2.1)四个数冒3轮
        8.2.2)每一轮都是从第1个元素开始冒
              每一次都和它的下一个元素比
        8.2.3)冒出来的就不带它玩了

9)计算程序执行时间：
    long a = System.currentTimeMillis();
    Arrays.sort(arr);
    long b = System.currentTimeMillis();

System.out.println(b-a); //排序消耗的毫秒数

冒泡排序执行过程：
int[] arr = {45,8,34,1}; //升序
第一轮:
  45和8比，换，8,45,34,1
  45和34比，换，8,34,45,1
  45和1比，换，8,34,1,45-------45冒出来了
第二轮:
  8和34比，不换
  34和1比，换，8,1,34,45-------34冒出来了
第三轮:
  8和1比，换，1,8,34,45--------8冒出来了

找最大值算法:

int[] arr = {23,45,67,10};
1)假设第1个元素最大
    int max = arr[0];
2)遍历剩余元素，将剩余元素与max对比，
  若剩余元素大于max，则修改max的值为较大的
    for(int i=1;i<arr.length;i++){
      if(arr[i]>max){
        max = arr[i];
      }
    }
max=23/45/67

数组操作代码演示：

  1. package day05;
  2. import java.util.Arrays;
  3.  
  4. //数组的演示
  5. public class ArrayDemo {
  6.     public static void main(String[] args) {
  7.         //6.数组的排序
  8.         int[] arr = {23,56,4,57,24,1,7,9};
  9.         Arrays.sort(arr); //对arr升序
  10.         for(int i=0;i<arr.length;i++){
  11.             System.out.println(arr[i]);
  12.         }
  13.  
  14.         /*
  15.         //5.数组的复制
  16.         int[] a = {10,20,30,40,50};
  17.         //数组的扩容(创建一个新的数组)
  18.         a = Arrays.copyOf(a,a.length+1);
  19.         for(int i=0;i<a.length;i++){
  20.             System.out.println(a[i]);
  21.         }
  22.         */
  23.         /*
  24.         int[] a = {10,20,30,40,50};
  25.         //a:源数组
  26.         //a1:目标数组
  27.         //6:目标数组的长度
  28.         int[] a1 = Arrays.copyOf(a,4);
  29.         for(int i=0;i<a1.length;i++){
  30.             System.out.println(a1[i]);
  31.         }
  32.         */
  33.         /*
  34.         int[] a = {10,20,30,40,50};
  35.         int[] a1 = new int[6];
  36.         //a:源数组
  37.         //1:源数组的起始下标
  38.         //a1:目标数组
  39.         //0:目标数组的起始下标
  40.         //4:复制的元素个数
  41.         System.arraycopy(a,1,a1,0,4);
  42.         for(int i=0;i<a1.length;i++){
  43.             System.out.println(a1[i]);
  44.         }
  45.         */
  46.  
  47.         /*
  48.         //4.数组的遍历
  49.         int[] arr = new int[10];
  50.         for(int i=0;i<arr.length;i++){
  51.             arr[i] = (int)(Math.random()*100);
  52.         }
  53.         for(int i=0;i<arr.length;i++){
  54.             System.out.println(arr[i]);
  55.         }
  56.         */
  57.  
  58.         /*
  59.         //3.数组的访问
  60.         int[] arr = new int[3];
  61.         System.out.println(arr.length); //3.
  62.         arr[0] = 100; //给arr中第1个元素赋值为100
  63.         arr[1] = 200;
  64.         arr[2] = 300;
  65.         //arr[3] = 400; //数组下标越界异常
  66.         System.out.println(arr[arr.length-1]); //300
  67.         */
  68.  
  69.         /*
  70.         //2.数组的初始化
  71.         int[] arr = new int[4]; //0,0,0,0
  72.         int[] arr1 = {1,4,6,8}; //1,4,6,8
  73.         int[] arr2 = new int[]{1,4,6,8}; //1,4,6,8
  74.         int[] arr3;
  75.         //arr3 = {1,4,6,8}; //编译错误
  76.         arr3 = new int[]{1,4,6,8}; //正确
  77.         */
  78.  
  79.         /*
  80.         //1.数组的定义
  81.         //声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
  82.         int[] arr = new int[10];
  83.         */
  84.     }
  85. }

求数组元素的最大值

  1. package day05;
  2. import java.util.Arrays;
  3. //求数组元素的最大值
  4. public class MaxOfArray {
  5.     public static void main(String[] args) {
  6.         //给arr赋值
  7.         int[] arr = new int[10];
  8.         for(int i=0;i<arr.length;i++){
  9.             arr[i] = (int)(Math.random()*100);
  10.             System.out.println(arr[i]);
  11.         }
  12.  
  13.         //找arr中的最大值
  14.         int max = arr[0]; //假设第1个元素最大
  15.         for(int i=1;i<arr.length;i++){ //遍历剩余元素
  16.             if(arr[i]>max){ //若剩余元素大于max
  17.                 max=arr[i]; //修改max的值为较大的
  18.             }
  19.         }
  20.         System.out.println("最大值为:"+max);
  21.  
  22.         //扩容
  23.         arr = Arrays.copyOf(arr,arr.length+1);
  24.         //将最大值赋值给arr中的最后一个元素
  25.         arr[arr.length-1] = max;
  26.         for(int i=0;i<arr.length;i++){
  27.             System.out.println(arr[i]);
  28.         }
  29.  
  30.     }
  31. }
  1. 九九乘法表
  1. package day05;
  2. //九九乘法表
  3. public class MultiTable {
  4.     public static void main(String[] args) {
  5.         for(int num=1;num<=9;num++){ //控制行
  6.             for(int i=1;i<=num;i++){ //控制列
  7.                 System.out.print(i+"*"+num+"="+i*num+"\t");
  8.             }
  9.             System.out.println(); //换行
  10.         }
  11.         /*
  12.          * num=4
  13.          *   ......
  14.          * num=3
  15.          *   i=1 1*3=3
  16.          *   i=2 2*3=6
  17.          *   i=3 3*3=9
  18.          *   i=4
  19.          *   换行
  20.          * num=2
  21.          *   i=1 1*2=2
  22.          *   i=2 2*2=4
  23.          *   i=3
  24.          *   换行
  25.          * num=1
  26.          *   i=1 1*1=1
  27.          *   i=2
  28.          *   换行
  29.          */
  30.  
  31.     }
  32. }

冒泡排序算法

  1. package day05;
  2. //冒泡排序算法
  3. public class BubbleSort {
  4.     public static void main(String[] args) {
  5.         /*
  6.          * 要求:
  7.          * 1.声明整型数组arr包含10个元素，
  8.          *   每个元素为0到99之间的随机数，
  9.          *   输出每个元素的值
  10.          * 2.冒泡方式对arr进行升序排列
  11.          * 3.输出arr排序后的数据
  12.          */
  13.         int[] arr = new int[10];
  14.         for(int i=0;i<arr.length;i++){
  15.             arr[i] = (int)(Math.random()*100);
  16.             System.out.println(arr[i]);
  17.         }
  18.         for(int i=0;i<arr.length-1;i++){ //控制轮数
  19.             for(int j=0;j<arr.length-1-i;j++){ //控制次数
  20.                 if(arr[j]<arr[j+1]){ //每次都是和它的下一个元素比
  21.                     int t = arr[j]; //满足条件则交换
  22.                     arr[j] = arr[j+1];
  23.                     arr[j+1] = t;
  24.                 }
  25.                 //若前数大于后数则交换，保证前数小于后数(升序)
  26.                 //若前数小于后数则交换，保证前数大于后数(降序)
  27.             }
  28.         }
  29.  
  30.         System.out.println("排序后:");
  31.         for(int i=0;i<arr.length;i++){
  32.             System.out.println(arr[i]);
  33.         }
  34.     }
  35. }

课后作业：

判断一个数字是否是质数：

  1. 方法一，判断？是否为质数：
  2. package day06;
  3. public class Test01 {
  4.     public static void main(String[] args) {
  5.         int num = 1;
  6.         boolean flag = true; //1.假设是质数
  7.         //for(int i=2;i<num;i++){ //2/3/4/.../98/99
  8.         //for(int i=2;i<=num/2;i++){ //2/3/4/.../49/50
  9.         for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10
  10.             if(num%i==0){
  11.                 flag = false; //2.修改为不是质数
  12.                 break;
  13.             }
  14.         }
  15.         if(flag){ //3.判断得结论 相当于if(flag==true){
  16.             System.out.println(num+"是质数");
  17.         }else{
  18.             System.out.println(num+"不是质数");
  19.         }
  20.     }
  21. }
  22.  
  23. 方法二，判断0~100之间的质数：
  24. package day06;
  25. import java.util.Scanner;
  26. public class Test01 {
  27.     public static void main(String[] args) {
  28.         int count = 0; //质数的个数
  29.         for(int num=2;num<=100;num++){
  30.             boolean flag = true;
  31.             for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10
  32.                 if(num%i==0){
  33.                     flag = false;
  34.                     break;
  35.                 }
  36.             }
  37.             if(flag){
  38.                 count++; //质数个数增1
  39.                 System.out.print(num+"\t");
  40.                 if(count%10==0){
  41.                     System.out.println();
  42.                 }
  43.             }
  44.         }
  45.     }
  46. }
  47.  
  48. 方法三，判断2~？之间哪些是质数：
  49. package day06;
  50. import java.util.Scanner;
  51. public class Test01 {
  52.     public static void main(String[] args) {
  53.         Scanner scanner = new Scanner(System.in);
  54.         System.out.print("请输入查找质数的范围：2~");
  55.         int max = scanner.nextInt();
  56.         scanner.close();
  57.         int numOfPrime = 0;
  58.         for (int n = 2; n <= max; n++) {
  59.             // 判断n是否是质数
  60.             int m = (int) Math.sqrt(n);
  61.             int i = 2;
  62.             for (; i <= m; i++) {
  63.                 if (n % i == 0)
  64.                     break;
  65.             }
  66.             if (i > m) {
  67.                 System.out.print(n + " ");
  68.                 if (++numOfPrime % 10 == 0)
  69.                     System.out.println();
  70.             }
  71.         }
  72.         System.out.println("\n共有" + numOfPrime + "个质数");
  73.     }
  74. }

求0~99之间的10个随机数，进行排序，并求出最小数为？

  1. 方法一：
  2. package day06;
  3. import java.util.Scanner;
  4. public class Test01 {
  5.     public static void main(String[] args) {
  6.         int[] arr = new int[10];
  7.         for(int i=0;i<arr.length;i++){
  8.             arr[i] = (int)(Math.random()*100);
  9.             System.out.println(arr[i]);
  10.         }
  11.  
  12.         int min = arr[0];
  13.         for(int i=1;i<arr.length;i++){
  14.             if(arr[i]<min){
  15.                 min=arr[i];
  16.             }
  17.         }
  18.         System.out.println("最小值为:"+min);
  19.  
  20.         int[] arr1 = new int[arr.length+1];
  21.         System.arraycopy(arr,0,arr1,1,arr.length);
  22.         arr1[0] = min;
  23.         for(int i=0;i<arr1.length;i++){
  24.             System.out.println(arr1[i]);
  25.         }
  26.     }
  27. }
  28.  
  29. 方法二：
  30. package day06;
  31. import java.util.Random;
  32. import java.util.Arrays;
  33. public class Test01 {
  34.     public static void main(String[] args) {
  35.         //创建一个 10 个长度的数组
  36.         int[] arr = new int[10];
  37.  
  38.         //随机生成 10 个0－99之间的数值，放入数组
  39.         Random ran = new Random();
  40.         for(int i=0;i<arr.length;i++){
  41.             arr[i] = ran.nextInt(100);
  42.         }
  43.         //打印数组中的数据
  44.         System.out.println("数组中的数据为：" + Arrays.toString(arr));
  45.  
  46.         //查询最小值
  47.         int min = arr[0];
  48.         for(int i=1; i<arr.length; i++) {
  49.             if(min > arr[i]) {
  50.                 min = arr[i];
  51.             }
  52.         }
  53.         System.out.println("最小值是：" + min);
  54.  
  55.         //创建新数组
  56.         int[] arrNew = new int[arr.length + 1];
  57.         //将原数组的元素拷贝进入新数组
  58.         System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);
  59.  
  60.         //最小值放入新数组第一位，并打印新数组
  61.         arrNew[0] = min;
  62.         System.out.println("新数组中的数据为：" + Arrays.toString(arrNew));
  63.     }
  64. }

day05-java-（循环问题，数组）的更多相关文章

  1. day05<Java语言基础--数组>

    Java语言基础(数组概述和定义格式说明) Java语言基础(数组的初始化动态初始化) Java语言基础(Java中的内存分配以及栈和堆的区别) Java语言基础(数组的内存图解1一个数组) Java ...

  2. java循环、数组练习

    System.out.println("请输入学生个数"); int a=sc.nextInt();//定义一个变量说明学生的数量 int max=0; int[] scores= ...

  3. Java循环和数组练习题：打印素数升级版

    前两天一个小伙伴问了我一个数组的练习题,我一看思路很清晰,就是打印素数加了个数组.没想到写的时候啪啪打脸,终究还是没逃过眼高手低.本来不打算发出来了,因为发出来愈发显得我很菜,最后还是打算分享出来,一 ...

  4. Java基础：数组的声明，循环，赋值，拷贝。

    数组的声明 一般有两种形式的声明: int[] a; int a[]; 这两种声明都没错,但是大多数都使用第一种声明,因为变量名是独立的,不带任何符号. 声明一个数组,并没有将a真正的初始化为一个数组 ...

  5. IT兄弟连 Java语法教程 数组 使用foreach循环遍历数组元素

    从JDK5之后,Java提供了一种更简单的循环:foreach循环,也叫作增强for循环,这种循环遍历数组和集合更加简洁.使用foreach循环遍历数组和集合元素时,无需获得数组或集合的长度,无需根据 ...

  6. Java中的数组

    1,可以创建自己的类的数组,但是自己的类必须实现get()和put函数 2,声明数组:int[] arrayOfInt.注意,定义数组时不可以指定大小 3,创建与初始化:通过new.arrayOfIn ...

  7. java学习之数组（二）

    在上一节中我们讲到了数组的概念,定义,以及在内存当中的表现形式.那么这里我们来说一下,数组的另一种定义方式. 在上一篇当中我们规定是这个样子定义数组的, class ArrDemo { public ...

  8. 【JAVA零基础入门系列】Day10 Java中的数组

    什么是数组?顾名思义,就是数据的组合,把一些相同类型的数放到一组里去. 那为什么要用数组呢?比如需要统计全班同学的成绩的时候,如果给班上50个同学的成绩信息都命名一个变量进行存储,显然不方便,而且在做 ...

  9. Java基础之数组(一)

    数组的定义 数组是相同类型数据的有序集合.数组描述的是相同类型的若干个数据,按照 一定的先后次序排列组合而成.其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们.数组的三个基本特 ...

  10. 第81节：Java中的数组

    第81节:Java中的数组 本节介绍数组的基本概念,数据就是一种数据结构,可以用来存储多个数据,每个数组中可以存放相同类型的数据.比如,在学校,我们是一个班,这里的班级中每个同学都是这个班级数组中的元 ...

随机推荐

  1. FlyCaptureProperty 摄像机属性

    An enumeration of the different camera properties that can be set via the API. Declaration enum FlyC ...

  2. MS14-025引起的问题 - 2

    5月,微软在13日发布月度安全更新,其中 有KB2871997和 KB2928120两个知识库文章Knowledgeased(而KB2871997甚至不是Security Bulletin).对于无论 ...

  3. PHP 错误与异常 笔记与总结（13 ）自定义异常类

    针对不同的异常,进行不同的处理,可以通过自定义异常类记录特定的异常信息来处理不同类型的异常.自定义异常类通过继承基类(Exception),对基类进行扩展. 自定义异常类 <?php heade ...

  4. in_array效率问题以及解决办法

    先将要对比的数组中的 键  和  值  设置成一样 然后用isset() 进行对比,存在则删除

  5. PHP抓取采集类snoopy介绍

    PHP抓取采集类snoopy介绍 一个PHP的抓取方案 在 2011年07月04日 那天写的     已经有 10270 次阅读了 感谢 参考或原文   服务器君一共花费了14.288 ms进行了2次 ...

  6. Ecshop、Discuz! 等开源产品的局限

    Ecshop.Discuz! 等开源产品的局限 记得今年年初,我初次接触Discuz!和Ecshop时,一阵阵地惊叹:成熟度这么高的产品,居然是免费的.我们这些搞传统软件开发的要怎么活?另外也奇怪,做 ...

  7. QT学习之-HelloWorld

    实现HelloWorld有2种方法. 第一种在mainwindow.ui直接添加Label且写上“HelloWorld”. 第二种是代码直接实现 #include "mainwindow.h ...

  8. maven库文件所在目录

    C:\Documents and Settings\jgzhang2\.m2\repository

  9. Supesite 参数说明

    supesite有人看到的是强大的功能,我看到的是坑爷的一些用法,第一次看到block,我晕了.对于参数一头雾水,下面收集了一些,备用吧. supesite标签调用参数详解 参数: blocktype ...

  10. Manipulating Data Structures

    Computer Science An Overview _J. Glenn Brookshear _11th Edition We have seen that the way data struc ...