数组

1.数组的概念

一组连续存储的空间，存储多个相同类型的数值，长度是固定的。

2.数组的定义

1.先声明、在分配空间：

​ 数组类型[] 数组名；

数组名 = new 数组类型[长度]；

2.声明并分配空间：

​ 数组类型 [] 数组名 = new 数组类型[长度];

3.声明并赋值（繁）:

​ 数组类型[] 数组名 = new 数组类型[]{value1,value2,value3,.....}

4.声明并赋值（简）：

​ 数组类型[] 数组名 ={value1,value2,value3,.....}；

package com.atguigu.demo.demo1;

/**
 *      数组：
 *      数组的四种定义方式：
 *           方式1 先声明 再分配空间
 *           方式2 连声明带分配空间
 *           方式3 声明并且赋值(繁)
 *           方式4 声明并且赋值(简)
 *
 */
public class Test1{
    public static void main(String [] args ){
        //方式1 先声明 再分配空间
        int [] array01;  //等价于int array01[] ; 
        arrray01 = new int [3];
        
        //方式2 连声明带分配空间
        int array02 = new int [3];
        
        //方式3 声明并且赋值(繁)
        int array03 = new int[]{1,2,3};
        
        //方式4 声明并且赋值(简)
        int array04 ={1,2,3};
        
    }
}

3.数组的下标和访问

元素：数组中的每一个数据称为元素

下标（索引|角标）：下标从0开始 自动生成 数组中的每个元素都可以通过下标来访问

数组的访问：访问包括赋值和取值

访问方式：数组名[index下标]

不能访问超出范围的下标，将会出现数组下标越界异常

package com.atguigu.demo.demo1;

/**
 * 元素：数组中的每个数据称之为元素
 *    下标/索引/角标 ： 下标从0开始  自动生成  数组中的每个元素可以通过下标来访问  访问包括赋值/取值
 *    访问方式：数组名[index下标]
 */
public class Test2{
    public static void main(String [] args){
        int [] arr1 = new int[5];

        // 赋值
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 56;
        arr1[3] = 78;
        arr1[4] = 88;
//        arr1[6] = 100; 不能访问超出下标范围的元素 将报数组下标越界以上  ArrayIndexOutOfBoundsException

        // 取值
        System.out.println("数组中的第1个元素值为：" + arr1[0]);
        System.out.println("数组中的第2个元素值为：" + arr1[1]);
        System.out.println("数组中的第3个元素值为：" + arr1[2]);
        System.out.println("数组中的第4个元素值为：" + arr1[3]);
        System.out.println("数组中的第5个元素值为：" + arr1[4]);
//        System.out.println("数组中的第6个元素值为：" + arr1[5]);
        // 不能访问超出下标范围的元素 将报数组下标越界以上  ArrayIndexOutOfBoundsException

    }
}

4.数组的访问

循环遍历：逐一将数组中的的每个元素进行访问 赋值取值

package com.atguigu.demo.demo1;

import java.util.Scanner;

/**
 *      循环的遍历：逐一将数组中的每个元素进行访问  赋值/取值
 */
public class{
    public static void main(String [] args){
       Scanner input = new Scanner(System.in);
        /*System.out.print("请输入数组名称：");
        String arrName = input.next();*/
        System.out.print("请输入数组长度");
        int arrLength = input.nextInt();

        int []  nums=new int[arrLength];


        // 通过循环给数组中的元素赋值
        for(int i = 0;i < 5;i++){
            System.out.println("请输入数组中的第" + (i + 1) + "个元素");

            nums[i] = input.nextInt();
        }

        System.out.println("元素赋值完成");

        // 通过循环将数组中的元素取出来
        for(int i = 0;i < 5;i++){
            System.out.print(nums[i] + "\t");
        }
        System.out.println();
    }
}

6.数组的属性及默认值

数组的属性：

​ length 表示数组的长度 是一个int类型的整数数值 可以通过数组名.length来查看数组长度

数组的默认值：

​ 整数：0

​ 小数：0.0

​ 布尔：false

​ 字符：\u0000

​ 其他：null

package com.atguigu.demo.demo1;

/**
 *      数组
 *      属性:
 *      length int型整数值 可以通过数组名.length来查看数组的长度
 *      默认值:
 *      整型：0
 *      浮点型：0.0
 *      Boolean：false
 *      char:\u0000  表示空字符
 *      其他：null
 */
public class Test4 {
    public static void main(String[] args) {
        System.out.println("=====================byte===================");
        byte [] b1 = new byte[5];
        for (int i = 0; i < b1.length; i++) {
            System.out.print( + b1[i]+"-\t");
        }
        System.out.println();

        System.out.println("=====================short===================");
        short [] s1 = new short[5];
        for (int i = 0; i < s1.length; i++) {
            System.out.print( s1[i]+"-\t");
        }
        System.out.println();

        System.out.println("=====================int===================");
        int [] i1 = new int[5];
        for (int i = 0; i < i1.length; i++) {
            System.out.print( i1[i]+"-\t");
        }
        System.out.println();

        System.out.println("=====================long===================");
        long [] l1 = new long[5];
        for (int i = 0; i < l1.length; i++) {
            System.out.print( l1[i]+"-\t");
        }
        System.out.println();

        System.out.println("=====================char===================");
        char [] c1 = new char[5];
        for (int i = 0; i < c1.length; i++) {
            System.out.print("-"+ c1[i]+"-");

        }
        System.out.println();
        System.out.print("------------");
        char cha1 = '\u0000';
        System.out.println(cha1);
        System.out.print("------------");
        System.out.println();


        System.out.println("=====================String===================");
        String [] str1 = new String[5];
        for (int i = 0; i < str1.length; i++) {
            System.out.print(str1[i]+"-\t");
        }
        System.out.println();
    }
}

6.数组扩容

• 数组的扩容

1. 创建比原数组更长的数组
2. 依次将原数组中的元素复制到新数组
3. 通过数组的赋值来实现数组扩容

数组作为引用数据类型，其数组名(引用)中存放的是指向堆中的地址，所以如果直接将一个数组赋值给另外一个数组，本质是赋值的地址

package com.atguigu.demo.demo1;

/**
 *          数组扩容：
 *              1.声明一个长度大于原数组的新数组
 *              2.将就数组里的值复制到新数组对应位置
 *              3.将新数组赋予旧数组（新数组代表地址的哈希值给旧数组）
 */
public class Test5 {
    public static void main(String[] args) {
        int [] oldArr={1,2,3,4,5};
        System.out.println(oldArr);

        //1.声明一个长度大于原数组的新数组
        int [] newArr = new int[oldArr.length*2];
        System.out.println(newArr);

        // 2.将就数组里的值复制到新数组对应位置
        for (int i = 0; i < newArr.length; i++) {
            newArr[i]=oldArr[i];
        }
        System.out.println("====");
        // 3.将新数组赋予旧数组（新数组代表地址的哈希值给旧数组）
        oldArr=newArr;
        System.out.println(oldArr);
        System.out.println(newArr);

        //输出
        for (int i = 0; i < oldArr.length; i++) {
            System.out.print(newArr[i]+"\t");
        }
    }
}

7.课堂练习

统计int类型数组中所有元素的总和。

统计int类型数组中所有元素的平均值。

package com.atguigu.demo.demo2;import java.util.Arrays;
import java.util.Scanner;

/**
 *      练习
 */
public class Test1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int [] arr1=new int[5];

        for (int i = 0; i < arr1.length; i++) {
            System.out.print("请输入第"+(i+1)+"各元素:");
            arr1[i] = input.nextInt();
        }

        System.out.println("数组元素之和为："+addArray(arr1));
        System.out.println("数组元素的平均数为："+averageArray(arr1));
        System.out.println("最大值："+maxArray(arr1));
        System.out.println("最小值："+minArray(arr1));


    }

   public static int addArray(int [] arr){
        int sum = 0;
       for (int i = 0; i < arr.length; i++) {
           sum+=arr[i];
       }

        return sum;
    }

    public static int averageArray(int [] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum/arr.length;
    }

    public static int maxArray(int [] arr){
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(max<arr[i]){
             max = arr[i];
            }
        }

        return max;
    }

    public static int minArray(int [] arr){
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        return min;
    }
}

8.复制数组的三种方式

复制数组的三种方式：

1. 自己编写循环实现复制
2. System.arraycopy（原数组，原起始位置，新数组，新起始位置，长度）；
3. java.util.Arrays.copyOf(原数组，新长度);此方法会返回一个新的数组···

package com.atguigu.demo.demo2;

import java.util.Arrays;

/**
 *      数组复制三种方法：
 *          1.自己写for循环复制;
 *          2.System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
 *          3.java.util.Arrays.copyOf(原数组，新长度); 此方法会返回一个新的数组;
 */
public class Test2 {
    public static void main(String[] args) {
        int [] oldArray = {1,2,3,4,5,6,7,8,9};

        //第一种：System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
        int [] newArray1 = new int[oldArray.length];
        System.arraycopy(oldArray,1,newArray1,2,(oldArray.length-2));
        printArray(newArray1);

        System.out.println("=============================================");

        //第二种：java.util.Arrays.copyOf(原数组，新长度); 此方法会返回一个新的数组;
        int [] newArray2 = Arrays.copyOf(oldArray,10);
        printArray(newArray2);

    }

    public static void printArray(int [] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
    }
}

9.数组参数/返回值/可变长参数

数组作为参数/返回值与之前使用方式一致

package com.atguigu.demo.demo2;

import java.util.Scanner;

/**
 *      数组类型的参数和返回值
 *         需求：
 *            1.编写方法统计一个班的学生成绩 作为返回值返回
 *            2.编写方法打印一个班的学生成绩
 */
public class Test3 {
    public static void main(String[] args) {
        double [] scores = getScore();

        printScore(scores);
    }

    public static double[] getScore(){
        Scanner input = new Scanner(System.in);

        System.out.println("请输入班级人数");

        int num = input.nextInt();

        double [] scores = new double[num];

        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个人的成绩");

            scores[i] = input.nextDouble();

        }

        return scores;
    }

    public static void printScore(double [] scores){
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第" + (i + 1) + "个人的成绩为：" + scores[i]);
        }
    }



}

可变长参数;

​ 概念：可接收0个或者多个同类型实参，个数不限，使用方式与数组相同。

​ 要求：只能在形参列表的末尾 形参列表中只能存在一个可变长参数

package com.atguigu.demo.demo2;

/**
 *      可变长参数：
 *          概念：可接收0个或多个同类型实参，个数不限，使用方式与数组相同
 *          要求：只能在形参列表的末尾，形参列表只能存在一个可变长参数
 */
public class Test4 {
    public static void main(String[] args) {
        add();
    }
    public static int add(int...array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return sum;
    }
}

10.面试题：值传递和“引用传递”的区别

面试题：值传递和"引用传递"的区别？

1. java中都属于值传递，当我们传递引用数据类型时，依然属于数据传递，只不过这个值就是一个引用|地址（代表地址的哈希值）；
2. 值传递,基本数据类型属于值传递，传递的是值本身的副本|拷贝 在方法中对变量进行操作不会影响原变量；
3. “引用传递”，引用数据类型，属于引用传递，传递的是地址，在方法中队参数进行操作会影响原变量；
4. String类型属于特殊的引用数据类型 作为参数传递不会改变原来的变量；

package com.atguigu.demo.demo3;

/**
 *      面试题：值传递和“引用传递”的区别？
 *          1.java中都属于值传递，当我们传递引用数据类型时，依然是数值传递，只不过这个值就是一个引用（地址|代表地址的哈希值）
 *          2.值传递：基本数据类型，属于值传递，传递的是值本身的一个拷贝|副本，在方法中对变量进行操作不会影响原变量。
 *          3.String类型属于特殊的引用类型，作为参数传递不会改变原变量的值
 */
public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        m1(a);
        System.out.println("main方法中a的值为：" + a);

        System.out.println("-----------------------------------------------------");

        int [] arr1 = {1,2,3,4,5};
        m2(arr1);
        System.out.println("main方法中打印arr1元素值");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();

        System.out.println("-----------------------------------------------------");

        String str = "abc";
        m3(str);
        System.out.println(str);

    }
    //值传递
    public static void m1(int num){
        num += 10;
        System.out.println("m1方法中num的值为：" + num);
    }
    //引用传递
    public static void m2(int [] nums){
        for (int i = 0; i < nums.length; i++) {
            nums[i]++;
            System.out.println("m2方法中打印元素值：" + nums[i]);
        }
        System.out.println("m2方法执行完毕");
    }
    //String传递
    public static void m3(String str){
        str += "hello";
    }
}

11.数据结构

线性表 数组、链表(单向链表，双向链表)

树：二叉树、二叉查找树、二叉平衡查找树、红黑树

数据结构参考网站:https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

12.排序

12.1冒泡排序

冒泡排序：两个相邻的元素来比较，如果条件成立则交换位置

​ 外层循环 n - 1

​ 内层循环 n - 1 -i

package com.atguigu.demo.demo4;

/**
 *      冒泡排序：两个相邻的元素来比较，如果条件成立则交换位置
 *          外层循环 n - 1
 *          内层循环 n - 1 -i
 */
public class Test1 {
    public static void main(String[] args) {
        int [] array1 = {123,111,132,89,141,99,105,80};

        // 外层循环控制比较的轮数   长度 - 1  (n- 1)
        // 内层循环控制每一轮比较的次数 最多的一次是长度-1  后续每轮依次递减1
        for (int i = 0; i < array1.length-1; i++) {
            for (int j = 0; j < array1.length-1-i; j++) {
                if(array1[j]>array1[j+1]){
                    int temp=array1[j+1];
                    array1[j+1]=array1[j];
                    array1[j]=temp;
                }
            }
        }

        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i]+"\t");
        }
        System.out.println("程序结束");
    }

}

12.2选择排序

选择排序：选择排序使用一个固定位置的元素，依次与其他元素进行比较。如果 遇到需要交换位置的元素，先不交换

​ 等待一轮比较完毕以后，统一换一次位置

外层循环充当比较的元素A 从第一个开始 到倒数第二个元素
内层循环充当比较的元素B 从第二个开始 后续每一轮 后延一位 直到最后一位

package com.atguigu.demo.demo4;

/**
 *      选择排序：选择排序使用一个固定位置的元素，依次与其他元素进行比较。如果遇到需要交换位置的元素，先不交换
 *              等待一轮比较完毕以后，统一换一次位置
 *      外层循环充当比较的元素A  从第一个开始 到倒数第二个元素
 *      内层循环充当比较的元素B  从第二个开始 后续每一轮 后延一位 直到最后一位
 */
public class Test2 {
    public static void main(String[] args) {
        int [] array1 = {123,111,132,89,141,99,105,80};

        // 外层循环充当比较的元素A  从第一个开始 到倒数第二个元素
        //内层循环充当比较的元素B  从第二个开始 后续每一轮 后延一位 直到最后一位
        for (int i = 0; i < array1.length-1; i++) {
            int index =i;
            for (int j = i; j < array1.length ; j++) {
                if(array1[index]>array1[j]){
                   index = j;
                }
            }
            if(index!=i){
                int temp = array1[index];
                array1[index]=array1[i];
                array1[i]=temp;
            }
        }

        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i]+"\t");
        }
    }
}