数组&工具类的使用

数组&工具类的使用

一维数组

概念：一组数据的容器（数组可以存放多个数据）
注意：
1.数组是引用数据类型
2.数组中的数据又叫做元素
3.每个元素都有编号叫做下标/索引
4.下标从0开始
5.数组初始化后，会在内存中开辟一连串连续的空间
6.数组一旦初始化后长度不可以改变（数组本身没有扩容和删除）
7.数组的操作：添加、修改、查询

​ 数组的声明：数据类型[] 数组名;
​ 数组的初始化：
​ 静态初始化：数据由程序员指定，长度由系统分配

​ 动态初始化：长度由程序员指定，数据由系统分配(默认值)
​ 整数类型：0
​ 浮点类型：0.0
​ 字符类型：’ ’ （空格）
​ 布尔类型：false
​ 引用类型：null(空)
​
​ 静态初始化 vs 动态初始化
​ 一开始就知道数据：静态初始化
​ 一开始就知道长度：动态初始化

public static void main(String[] args){
    //静态初始化1
    String[] names1 = new String[]{"张三","李四","王五","小红","小明"};

    //静态初始化2
    String[] names2;
    names2 = new String[]{"张三","李四","王五","小红","小明"};

    //静态初始化3
    String[] names3 = {"张三","李四","王五","小红","小明"};

    //动态初始化1
    String[] names4 = new String[5];//5->5个长度

    //设置指定下标上的元素
    names4[0] = "aaa";
    names4[1] = "bbb";
    names4[2] = "ccc";
    names4[3] = "ddd";
    names4[4] = "eee";

    //设置指定下标上的元素
    names4[3] = "xyz";

    //获取指定下标上的元素
    String n = names4[3];
    System.out.println("获取指定下标上的元素：" + n);//xyz

    //ArrayIndexOutOfBoundsException - 数组下标越界异常
    //System.out.println(names[100]);

    //获取元素个数
    int len = names4.length;
    System.out.println("获取元素个数：" + len);//5

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

    //遍历 - for循环
    for(int i = 0;i<names4.length;i++){
    System.out.println(names4[i]);
    }
    System.out.println("-----------");

    //遍历 - foreach(增强for循环)
    for(String str:names4){//遍历数组，依次把元素赋值给str
    System.out.println(str);
    }
}

案例
需求：定义一个10个长度的int数组，获取最大值
    
public static void main(String[] args){
		
	int[] is = {3,2,4,35,34,5,25,39,32,18};
	int max = is[0];//假设数组中第0个下标位置的元素为最大值
	int index = 0;

	for(int i = 1;i<is.length;i++){
		if(max < is[i]){
			max = is[i];
			index = i;
		}
	}
	
    //最大值为:39,下标为:7
	System.out.println("最大值为:" + max + ",下标为:" + index);
}

注意：

​ 遍历时要使用到下标，就用for循环遍历
​ 遍历时不使用到下标，就用foreach遍历

数组的排序

冒泡排序

口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i

自学各种排序：https://www.cnblogs.com/c1024/p/11012049.html

public static void main(String[] args){   
   
	int[] is = {39,77,27,20,45,62};
   for(int i = 0;i<is.length-1;i++){
       for(int j = 0;j<is.length-1-i;j++){
           if(is[j] > is[j+1]){
               int temp = is[j];
               is[j] = is[j+1];
               is[j+1] = temp;
           }
       }
   }

   for(int num : is){
       System.out.print(num + " ");//20 27 39 45 62 77 
   }
}

数组的查找

顺序查找

从头到尾遍历:

for(int i = 0;i<is.length;i++){
    if(is[i] == num){
        System.out.println("查找到了");
    }
}

二分法查找

前提：先排序

二分查找：搜索数字，找到就返回下标，否则给出相应的提示信息

public static void main(String[] args){

    int[] is = {39,77,27,20,45,62};
    int num = 12;

    //排序
    Arrays.sort(is);
//    for (int i = 0; i < is.length; i++) {
//        System.out.println(is[i]);
//   }

    int res = binarySearch(is,num);
    if(res>=0){
        System.out.println(num + "的下标为:" + res);//排序后的下标
    }else {
        System.out.println("数组中无数字" + num);
    }
}

public static int binarySearch(int[] is, int target) {
	int left = 0; 
    int right = is.length - 1; 

    while(left <= right) {
        int mid = (right + left) / 2;
        if(is[mid] == target)
            return mid; 
        else if (is[mid] < target)
            left = mid + 1; 
        else if (is[mid] > target)
            right = mid - 1; 
    }
    return -1;
}

数组高级

数组的复制

知识点：数组的复制1

缺点：修改源数组，新数组的数据也随之改变

public static void main(String[] args){
	//源数组
	String[] names = {"张三","李四","王五","小红","小明"};
	
	//新数组
	String[] newNames = names;
	
	//修改源数组
	names[0] = "小王";
	
	//遍历新数组
	for(String name : newNames){
		System.out.println(name);
	}
}

知识点：数组的复制2

public static void main(String[] args){
   	//源数组
   	String[] names = {"张三","李四","王五","小红","小明"};

       //新数组
       String[] newNames = new String[names.length];

       //将源数组中数据依次赋值给新数组
       for(int i = 0;i<names.length;i++){
           newNames[i] = names[i];
       }

       //修改源数组
       names[0] = "小张";

       //遍历新数组
       for(String name : newNames){
           System.out.println(name);
       }
}

数组的扩容

知识点：数组的扩容

//源数组
 String[] names = {"张三","李四","王五","小红","小明"};
   
 //新数组
    int capacity = names.length+(names.length>>1);//新容量：是源数组长度的1.5倍
    String[] newNames = new String[capacity];
   
 //把源数组所有的数据迁移到新数组中
    for(int i = 0;i<names.length;i++){
        newNames[i] = names[i];
    }
   
 //将新数组的地址赋值给源数组
    names = newNames;
   
 //遍历源数组
    for(String name:names){
        System.out.println(name);
    }

数组的删除

知识点：数组的删除1

缺点：数组原本是存放数据的，删除元素后，数组长度变短

public static void main(String[] args){
    //源数组
    String[] arr = {"aaa","bbb","ccc","eee"};

    //新数组
    String[] newArr = new String[arr.length-1];

    //将源数组的数据迁移到新数组中，要删除的元素(深田咏美)除外
    int index = 0;//新数组的下标
    for(String name:arr){
        if(!name.equals("ccc")){
            newArr[index] = name;
            index++;
        }
    }

    //将新数组的地址赋值给源数组
    arr = newArr;

    //遍历源数组
    for(String name:arr){
        System.out.println(name);
    }
}

知识点：数组的删除2

删除元素后，空间依旧存在，数组的长度不变

public static void main(String[] args){
    //源数组
    String[] arr = {"aaa","bbb","ccc","eee"};

    //数据的迁移
    for(int i = 1;i<arr.length-1;i++){
        arr[i] = arr[i+1];
    }
    arr[arr.length-1] = null;

    //遍历源数组
    for(String name:arr){
        System.out.println(name);
    }
}

数组的参数和返回值

需求：设计一个方法，传入数组，返回最大值和最小值

public static void main(String[] args){
		int[] is = {1,2,3,4,5,6};
		
		int[] newArr = method(is);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
   public static int[] method(int[] is){
       int max = is[0];
       int min = is[0];
       for(int i = 1;i<is.length;i++){
           if(max < is[i]){
               max = is[i];
           }
           if(min > is[i]){
               min = is[i];
           }
       }

       return new int[]{max,min};
}

可变参数

注意：可变参数底层就是数组

需求：设计一个方法，传入五个int值，求和

public class Demo01 {
	public static void main(String[] args){

	    int sum = add(1,2,3,4,5,6,7,8,9,10);//实参作为元素，压入到数组中
	    System.out.println(sum);//55
	}

	//is就是数组
	public static int add(int... is){
	    int sum = 0;
	    for(int num : is){
	        sum += num;
	    }
	    return sum;
	}

	//注意：可变参数后不能接其他参数，有多个参数时，可变参数写在最后
	public static void method(int a,String... ss){}
}

知识点：main方法中的args参数 (使用cmd窗口编译)

​ 编译：javac Test10.java
​ 运行：java Test10 小红 小绿 小黄
​ 把小红 小绿 小黄 三个元素压入args数组中

public static void main(String[] args){

	for(String str : args){
		System.out.println(str);
	}
}

Arrays工具类

Arrays：java给我们提供的专门操作数组的工具类
工具类：类里的所有方法都是静态的（直接使用类名调用）
API：java类的使用说明书

public static void main(String[] args){

    int[] is = {39,77,27,20,45,62};

    //排序: 20 27 39 45 62 77
    Arrays.sort(is);

    //查找(返回值：如果元素在数组中就返回下标，否则返回 -(插入点+1) )
    int index =  Arrays.binarySearch(is,42);
    System.out.println("查找元素的下标为：" + index);

    //替换
    Arrays.fill(is,888);
    Arrays.fill(is,1,4,666);

    //拷贝
    int[] copyOf = Arrays.copyOf(is,is.length*2);//长度为原数组的2倍
    for (int i : copyOf) {
        System.out.println(i);
    }
    System.out.println("-------");

    int[] copyOfRange = Arrays.copyOfRange(is,3,8);
    for (int i : copyOfRange) {
        System.out.println(i);
    }
    //获取数组的字符串表示(将数组转换为字符串)
    System.out.println(Arrays.toString(copyOfRange));
}

二维数组

含义：包含了多个一维数组

声明：数据类型[][] 数组名;

静态初始化

数据由程序员指定，长度由系统自动分配

public static void main(String[] args){
	
    //静态初始化1
    //String[][] names = new String[][]{{"aa","bb","cc"},{"ff","rr","tt","kk"}};

    //静态初始化2
    //String[][] names;
    //names = new String[][]{{"aa","bb","cc"},{"ff","rr","tt","kk"}};

    //静态初始化3
    String[][] names = {{"aa","bb","cc"},{"ff","rr","tt","kk"}};

    //设置指定下标上的元素
    names[0][2] = "张三";

    //获取指定下标上的元素
    String name = names[0][2];
    System.out.println("获取指定下标上的元素：" + name);//张三

    //获取长度
    System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
    System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
    System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4

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

    //遍历 - for循环
    for (int i = 0; i < names.length; i++) {
        for (int j = 0; j < names[i].length; j++) {
            System.out.println(names[i][j]);
        }
    }

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

    //遍历 - foreach
    for (String[] strings : names) {
        for (String string : strings) {
            System.out.println(string);
        }
    }
}

动态初始化

长度由程序员指定，数据由系统赋默认值
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null

    //动态初始化1
       //String[][] names = new String[2][3];//2个一维数组，每个一维数组中有3个元素

       //动态初始化2
       String[][] names;
       names = new String[2][3];//2个一维数组，每个一维数组中有3个元素

       //设置指定下标上的元素
       names[0][0] = "aaa";
       names[0][1] = "bbb";
       names[0][2] = "ccc";
       names[1][0] = "ddd";
       names[1][1] = "eee";
       names[1][2] = "fff";

需求：使用动态初始化二维数组，其中第一个一维数组有3个元素，第二个一维数组有4个元素

       //动态初始化：标注二维数组中有2个一维数组
       String[][] names = new String[2][];

       //把长度为3的一维数组赋值给二维数组中下标为0的位置
       names[0] = new String[3];
       //把长度为4的一维数组赋值给二维数组中下标为1的位置
       names[1] = new String[4];

       System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
    System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
    System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4