java学习第五天

java学习第五天

数组

用于存储相同类型的一组数据，它是一种数据结构，也是java中的一种类型。

• 一个数组有多个数据（元素）
• 一个数组里面的元素都是相同类型
• 数组的元素用序号（下标，从0开始）访问
• 数组一旦初始化后，长度不能改变

定义数组

数组的定义与变量类似，就是在变量后面加一对[]

• 只定义数组，没有分配内存空间

• 没有长度

  **注意：**数组可以按这样的方式定义：int arr[];，但是不推荐

      //数组的定义与变量类似，就是在变量后面加一对[].
      int[] arr;
      char[] a1;
      boolean[] a2;
      String[] a3;
  

初始化数组

指定长度，分配内存空间，每个元素给初始化的值。

• new 类型[长度]

• new 类型[]{}

• 类型[] 数组变量 = {}

  如果数组初始化时没有赋值，按下面的规则给数组元素赋值

  数据类型	默认值
  byte、short、int、long	0
  float、double	0.0
  char	'\u0000’不可见字符
  boolean	false
  引用类型	null

       arr = new int[10];//int类型的数组默认初始值是0
        a1 = new char[]{'A', 'B', 'c'};//初始化的同时赋值
        String[] a4 ={"张三", "李四"};//在数组定义时，直接用{}赋值和初始化。

使用数组

用数组的变量名[],中括号里面写上下标，就可以读写数组的元素。

• 下标不能越界，否则会抛出异常
• 数组长度可通过lenght属性获得

        //数组的使用
        //变量名[下标] 这样就能访问数组的元素
        System.out.println(a1[1]);
        a1[1] = 68;//元素赋值
        System.out.println(a1[1]);
        //访问数组元素时，如果下标超出范围，会抛出异常（数组下标越界）
 
		//数组的长度，lenght属性。
        System.out.println(arr.length);

数组的遍历

• for循环

for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

• foreach循环

  for(类型 变量名 : 数组名){

  ​ //变量的值就是数组里的元素。

  }

        //foreach,增强的for循环，只能针对数组、集合。不能给数组赋值
        for (int i:arr) {
            System.out.println(i);//打印数组的每个元素。
        }

二维数组

        int[][] arr = { {20,26,50},
                        {30,2,5,6}};
//遍历数组
        //System.out.println(arr[0][0]);
       /* for (int i = 0; i < arr[0].length; i++) {
            System.out.println(arr[0][i]);
        }*/
//遍历所有数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
 		//初始化时外层数组和内层数组都指定长度
        int[][] arri = new int[5][3];
        //初始化时可以只指定外层数组长度
        int[][] arrj = new int[5][];
        //初始化数组时，长度可以不一样
        int[][] arrk = new int[][]{{3,6},{4,5,9}};

Array类的使用

        String[] arr = {"张三","李四","王五"};
        //在数组忠搜索一个元素，搜到则返回元素的下标，没有搜到则返回负数。
        int i = Arrays.binarySearch(arr, "李四");//返回搜到的元素的下标给i
        System.out.println(i);

        //复制一个新的数组，第一个参数是原数组，第二个参数是新参数的长度。
        String[] arr1 = Arrays.copyOf(arr, 6);
        System.out.println(arr1.length);
        System.out.println(arr1[5]);

        //把数组转为字符串
        System.out.println(Arrays.toString(arr1));

        //对数组排序（升序）
        int[] arr2 = {5,6,90,8,40,52};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
    }

数组冒泡排序

		int[] arr2 = {5,6,90,8,40,52};
//外层循环控制需要排序的元素的个数，只需要数组长度减1
		for (int j = 0; j < arr2.length - 1; j++) {
            //用第一个元素与之后面的数对比，以及排好的数就不需要在对比，所以每排好一个数之后，最大的下标就减1，（arr2.length-1 - j）
            for (int k = 0; k < arr2.length-1 - j; k++) {
                //相邻两个数比较，大的往后面放。
                if(arr2[k]>arr2[k + 1]){
                    int temp = arr2[k +1];
                    arr2[k+1] = arr2[k];
                    arr2[k] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr2));

练习：

1. 斐波拉契数列算法题。

   //a和b是数列忠连续的两个数字。
           for (int i = 3, n = 24, a = 1, b = 1, c = 0; i <= n; i++) {
               //交换数据
               c = a + b;//前面两个月的数量和
               a = b;
               b = c;
               System.out.println("第"+i+"各月"+"，共有"+b);
           }
   

2. 打印100-999之间个十百三个数字不重复的数字。如：123,456,789,147,258,369

    //打印100-999之间不相等的数字
           int j;
           int k;
           int l;
           for (int i = 100; i <= 999; i++) {
               j = i % 10;
               k = i / 10 % 10;
               l = i / 100;
               if(j != k && j!= l && k!=l)
                   System.out.println(i);
           }
   

3. 输入一个数字，判断是否是回文数（正序和倒序是一样的）如，121,131

          Scanner in = new Scanner(System.in);
           while (true) {
               System.out.println("请输入一个整数：");
               int input = in.nextInt();
               int i;
               int sum = 0;
               int record = input;
               while (record % 10 != 0) {
                   i = record % 10;
                   sum = sum * 10 + i;
                   record /= 10;
               }
               if (sum == input) System.out.println(input + " 是回文数");
               else System.out.println(input + " 不是回文数");
           }
   

4. 输入两个数字，求它们的最大公约数。

           //最大公约数
           Scanner scanner = new Scanner(System.in);
           while (true) {
               System.out.println("请输入一个整数");
               int one = scanner.nextInt();
               System.out.println("请再输入一个整数");
               int two = scanner.nextInt();
   
               int common = 0;
               for (int j = 1; j <= (Math.min(one, two)); j++) {
                   if (two % j == 0 && one % j == 0 && common<j) {
                       common = j;
                   }
               }
               System.out.println(common);
           }