Java数组

目录

数组

数组的声明与赋值

数组的三种声明方

数组下标越界

读取未赋值数组下标位置获取到的是该数组数据类型的默认值

数组的数据类型与长度

数组的遍历

Arrays.toString

for循环实现Arrays.toString

        增强for循环实现Arrays.toString

        数组的合并

        第三方实现值的交互

        数组的最大/最小值

        数组的升序降序

        数组排序

        用copyOf生成新数组

        用System.arraycopy截取数组的长度存储到另一个数组中

         二维数组的声明与赋值与读取二维数组的元素

         遍历二维数组

         二维数组的遍历

         利用数组随机姓名

         可变数组

---

1：数组

（1）同数据类型的元素组成的集合我们称之为数组

（2）数组中能够存储元素数量的最大值我们称之为该数组的长度

（3）该数组声明后长度不可修改

（4）数组声明后长度不可修改

（5）数组声明后没有赋值的index位置上赋值为2:该数组数据类型的初始值/默认值

public class ArrayTest {
     @Test
     public void teat01() {
//	int a = 10;
//	int b = 20;
//	int c = 30;
//	int a = 10, b = 20, c = 30;
// 相同元素组成的集合称之为数组
    int[] array = {10, 20, 30};
    }

}	
		
	

2：数组的声明与赋值

@Test
public void teat02() {
// 声明一个长度为5的数组
	int[] array = new int[5];
	// 为下标为2的位置赋值
	array[2] = 20;
	// 读取下标为2位置上元素的值
System.out.println(array[2]);
}

3：数组的三种声明方式

@Test
// 数组的三种声明方式
public void teat03() {
	//注意{}中代表元素的值而非长度
	int[] arr0 = new int[] {5};
	// 注意：[]中的5代表元素的长度而非元素的值
	int[] arr1 = new int[5];
	int[] arr2 = {5};
 }

4：数组下标越界

@Test
public void teat04() {
	// 声明一个长度为5的数组
	int[] array = new int[5];
	// 为下标为2的位置上元素赋值
	array[2] = 20;
	// 读取下标为2位置上元素的值
	System.out.println(array[2]);
	// 数组下标越界
	System.out.println(array[6]);
}

5：读取未赋值数组下标位置获取到的是该数组数据类型的默认值

@Test
public void teat05() {
	// 声明一个长度为5的数组
	int[] array = new int[5];
	// 为下标为2的位置上元素赋值
	array[2] = 20;
	// 读取下标为2位置上元素的值
	System.out.println(array[2]);

	System.out.println(array[3]);
 }
 @Test
public void teat06() {
	byte[] arr00 = new byte[5];
		short[] arr01 = new short[5];
		int [] arr02 = new int[5];
		long [] arr03 = new long[5];
		double[] arr04 = new double[5];
		float[] arr05 = new float[5];
		char[] arr06 = new char[5];
		boolean[] arr07 = new boolean[5];
		String[] arr08 = new String[5];
		// 读取没有赋值的位置上的元素读到的是该数组数据类型的默认值
		
		// byte 0
		System.out.println(arr00[2]);
		// short 0
		System.out.println(arr01[2]);
		// int 0
		System.out.println(arr02[2]);
		// long 0
		System.out.println(arr03[2]);
		// double 0
		System.out.println(arr04[2]);
		// float 0 
		System.out.println(arr05[2]);
		// char 0 
		System.out.println(arr06[2]);
		// boolean 0 
		System.out.println(arr07[2]);
		//null
		System.out.println(arr08[2]);
		System.out.println("\0");
}

6：数组的数据类型与长度

    @Test
    public void test07() {
		// 引用数据类型
		// 数组一旦声明长度不可不变
		String[] arr0 = new String[3];
		arr0[0] = "我";
		arr0[1] = "爱";
		arr0[2] = "你";
		System.out.println(arr0[0]);
		System.out.println(arr0[1]);
		System.out.println(arr0[2]);
  
		arr0 = new String[5];
		System.out.println(arr0[0]);
		System.out.println(arr0[1]);
		System.out.println(arr0[2]);
	}

7：数组的遍历

@Test
public void test08() {
    // 遍历数组
    String[] arr0 = new String[3];
    arr0[0] = "我";
    arr0[1] = "爱";
    arr0[2] = "你";
	for (int i = 0; i < 3; i++) {
	     System.out.print(arr0[i]);
				
	}
			
}
@Test
public void test09() {
    // 遍历数组
    String[] arr0 = new String[3];
    arr0[0] = "我";
    arr0[1] = "爱";
    arr0[2] = "你";
    //数组.length获取该数组的长度
    System.out.println(arr0.length);
		
}
@Test
public void test10() {
    // 遍历数组
    String[] arr0 = new String[3];
    arr0[0] = "我";
    arr0[1] = "爱";
    arr0[2] = "你";
    System.out.println("数组array的长度 >>> " + arr0.length);
    for (int i = 0; i < 3; i++) {
        System.out.print(arr0[i]);
				
    }
}

8：Arrays.toString（数组输出时带上[ ]）

@Test
public void test11() {
    // 遍历数组
    String[] arr0 = new String[3];
    arr0[0] = "我";
    arr0[1] = "爱";
    arr0[2] = "你";
    System.out.println(Arrays.toString(arr0));
}

9：for循环实现Arrays.toString

  @Test
    public void test12() {
        String[] array = {"我","爱","你"};
        // System.out.print(Arrays.toString(array));
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            String string = array[i];
            if(i < array.length -1) {
                System.out.print(string + ",");
            }else {
                System.out.print(string);
            }
        }
        System.out.print("]");
}

10：增强for循环实现Arrays.toString

// 增强for循环
    @Test
    public void test13() {
        String[] array = {"我","爱","你"};
        for (String string : array) {
        System.out.print(string);
    }

}

11：数组的合并

public class ArraysTest {
	@Test 
	public void test01() {
		String[] array = {"我","爱","你","中","国"};
		System.out.println(Arrays.toString(array));
			
	}
	@Test·    
	public void teat02() {
		 int[] arr0 = {0, 2, 4, 6, 8};
		 int[] arr1 = {1, 3, 5, 7, 9};
		 //需求:将以上两个数组合并为一个新的数组
		 
		 //思路:
		 // 1:声明一个新的数组长度为两个数组长度之和
		 // 2:将第一个数组循环赋值给新数组
		 // 3:将第二个数组循环遍历为新数组 注意第二个数组的起始位置
		 int[] arr2 = new int[arr0.length + arr1.length];
		 // 遍历第一个数组
		 for (int i = 0; i < arr0.length; i++) {
			 // 获取第一个数组的元素
			 
			 arr2[i] = arr0[i];
		 }
		 // 遍历第二个数组
		 for (int i = 0; i < arr1.length; i++) {
			// 获取第二个数组
			
			 arr2[arr0.length + i] = arr1[i];
		 	}
			System.out.println(Arrays.toString(arr2));
		}
	@Test
	public void teat03() {
		 int[] arr0 = {0, 2, 4, 6, 8};
		 int[] arr1 = {1, 3, 5, 7, 9};
		 //需求：按照下标相同的位置依次将以上两个数组中的元素插入新的数组
		 //思路	1：声明一个新的数组长度为两个数组的和
		 //		2:将第一个数组循环赋值给新数组，注意下标为2n
		 //		3:将第二个数组循环赋值给新数组，注意下标为2n+1
		 //     4:第二个数组长度如果与第一个数组长度不一样怎么办？
		 int [] arr2 = new int[arr0.length + arr1.length];
		 // 遍历第一个数组
		 for (int i = 0; i < arr0.length; i++) {
			 // 获取第一个数组的元素
			 
			 arr2[2*i] = arr0[i];
		 }
		 // 遍历第二个数组
		 for (int i = 0; i < arr1.length; i++) {
			// 获取第二个数组
			
			 arr2[2*i + 1] = arr1[i];
		 	}
			System.out.println(Arrays.toString(arr2));
		}
  	@Test
	public void teat05() {
		 int[] arr0 = {0, 2};
		 int[] arr1 = {1, 3, 5, 7, 9};
		
		//需求：按照下标相同的位置依次将以上两个数组中的元素插入新的数组
		 //思路	1：声明一个新的数组长度为两个数组的和
		 //		2:将第一个数组循环赋值给新数组，注意下标为2n
		 //		3:将第二个数组循环赋值给新数组，注意下标为2n+1
		 //     4:第二个数组长度如果与第一个数组长度不一样怎么办？
		 //     思路： 当第一个数组复制完成之后第二个数组依次赋值即可
		 int [] arr2 = new int[arr0.length + arr1.length];
		 // 循环次数找两个数组长度最大的那个数组
		 int max = arr0.length  > arr1.length ? arr0.length : arr1.length;
		 int min = arr0.length < arr1.length ? arr0.length : arr1.length;
		 //返回长度最长的那个组
		 int[] maxArray = arr0.length > arr1.length ?  arr0 : arr1; 
		 //循环次数为两个数组中长度最大的那个长度
		 for (int i = 0; i < max; i++) {
			 if(i < min) {
				 arr2[2 * i] = arr0[i];
				 arr2[2 * i + 1] = arr1[i];
			 }else {
				 arr2[i + min] = maxArray[i];
			 }			 
		}
		 System.out.println(Arrays.toString(arr2));
	}
	
}

12：第三方实现值的交互

public class ArraySort {
	@Test
	public void test01() {
		//需求：将变量a和变量b进行值的交互（请使用三种方式实现）
		int a = 10, b = 20;
		//(1)思路：使用中间变量
		// 虽然多使用了变量但是容易理解（推荐使用）
		int c = a;
		 b = c;
		 a = b;
		 System.out.println("a >>> " + a);
		 System.out.println("b >>> " + b);
	}

	@Test
	public void test02() {
		//需求：将变量a和变量b进行值的交互（请使用三种方式实现）
		int a = 10, b = 20;
		//(1)思路：借助数学公式 但不推荐 有数据失真的风险
		
		 a = a + b;
		 b = a - b;
		 a = a - b;
		 System.out.println("a >>> " + a);
		 System.out.println("b >>> " + b);
	}

	@Test
	public void test03() {
		//需求：将变量a和变量b进行值的交互（请使用三种方式实现）
		int a = 10, b = 20;
		//(1)思路：借助位运算符 但不推荐 虽然效率高但是不好理解
		// 虽然多使用了变量但是容易理解（推荐使用）
		a = a ^ b;
		b = a ^ b;
		a = a ^ b;
		 System.out.println("a >>> " + a);
		 System.out.println("b >>> " + b);
	}
}

13：数组的最大/最小值

public class SortTest {
	@Test
	public void test01() {
		int[] array  = {23, 34, 36, 27, 89, 77};
		System.out.println(Arrays.toString(array));
		Arrays.sort(array);
		System.out.println(Arrays.toString(array));
	}

	@Test
	public void test02() {
		//需求获取数组中的最大值
		int[] array  = {23, 34, 36, 27, 89, 77};
		// 思路：找一个中间变量 将数组中的最后一个位置上的元素存储在该中间变量中 然后依次比较数组中所有元素的值
		// 获取数组的最后一个元素
		int max = array[array.length - 1];
		for (int i = 0; i < array.length - 1; i++) {
		// 获取元素的值
		int j = array[i];
	    // 和中间变量比较 将最大赋值给中间变量
		max = max > j ? max : j;
	}	
	System.out.println("数组中的最大值为 >>> " + max);
	}

	@Test
	public void test03() {
		//需求获取数组中的最小值
		int[] array  = {23, 34, 36, 27, 89, 77};
		// 思路：找一个中间变量 将数组中的最后一个位置上的元素存储在该中间变量中 然后依次比较数组中所有元素的值
		// 获取数组的最后一个元素
		int min = array[array.length - 1];
		for (int i = 0; i < array.length - 1; i++) {
		// 获取元素的值
		int j = array[i];
	    // 和中间变量比较 将最大赋值给中间变量
		min = min < j ? min : j;
	}	
	System.out.println("数组中的最小值为 >>> " + min);
	}
 }

14：数组的升序降序

    @Test
	public void test04() {
		// 需求： 数组升序
		int[] array = {23, 34, 36, 27, 89, 77};
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - 1 -i; j++) {
				// 获取元素的值
				if (array[j] > array[j + 1]) {
					int x = array[j];
					array[j] = array[j + 1];
					array[j + 1] = x;
					
				}
			}
			
		}
		System.out.println(Arrays.toString(array));
	}
	@Test
	public void test05() {
		// 需求： 数组降序
		int[] array = {23, 34, 36, 27, 89, 77};
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - 1 -i; j++) {
				// 获取元素的值
				if (array[j] < array[j + 1]) {
					int x = array[j];
					array[j] = array[j + 1];
					array[j + 1] = x;
					
				}
			}
			
		}
		System.out.println(Arrays.toString(array));
	}

}

15：数组排序

// 十大经典排序算法
	//1:冒泡排序
	//2:选择排序
	//3:插入排序
	//4:希尔排序
	//5:归并排序
	//6:快速排序
	//7:堆排序
	//8:计数排序
	//9:桶排序
	//10:基数排序

16：用copyOf生成新数组

public class ArraysTest {
    @Test
    public void test10() {
	//copyOf(原数组，新数组长度) =  数组的拷贝
	String[] arr0 = {"我","爱","你"};
	System.out.println(Arrays.toString(arr0));
 			
			
	String[] arr1 =Arrays.copyOf(arr0, 5);
	String[] arr2 =Arrays.copyOf(arr0, 2);
			
	System.out.println(Arrays.toString(arr1));
	System.out.println(Arrays.toString(arr2));
		}
}

17：用System.arraycopy截取数组的长度存储到另一个数组中

@Test
public void teat11() {
    int[] arr0 = {0, 2, 4, 6, 8};
    int[] arr1 = {1, 3, 5, 7, 9};
     System.arraycopy(arr0, 1, arr1, 2, 2);
     System.out.println(Arrays.toString(arr1));
		
		
    }
}		

18：二维数组的声明与赋值与读取二维数组的元素

@Test
public void teat12() {
    String[][] classes = {
	    {"java01", "java02","java03"},
	    {"python01", "python02", "python03"},
	    {"go01", "go02", "go03"}
	    };

    System.out.println(classes[0][1]);
    System.out.println(classes[1][0]);
    System.out.println(classes[2][2]);
		}
}

19：遍历二维数组

@Test 
public void test13() {
    String[][] classes = {		
                {"java01", "java02","java03"},
                {"python01", "python02", "python03"},
                {"go01", "go02", "go03"}
    
              };
	    for (int i = 0; i < classes.length; i++) {
                    // 获取一维数组的元素
		    String[] strings = classes[i];
         	    for (int j = 0; j < strings.length; j++) {
		    //获取二维数组的元素
		    String string = strings[j];
	            System.out.println( "\t" + string);
					
		}
                  System.out.println("\n");
	}
			
}
@Test 
public void test14() {
    String[][] classes = {		
	        {"java01", "java02","java03"},
		{"python01", "python02", "python03"},
	        {"go01", "go02", "go03"}
		    };
	    for (int i = 0; i < classes.length; i++) {
	    // 获取一维数组的元素
	    for (int j = 0; j < classes[i].length; j++) {
	    //获取二维数组的元素
            System.out.println("\t" +  classes[i][j]);
						
                }
		System.out.println("\n");
		}
				
				
	}
}

20：二维数组的遍历

        @Test
    	public void test15() {
    		// 班级名称前缀
    		String[] cousePreFix = {"java","python","go" };
    		// 班级数组
    		String[][] classes = new String[3][20];
    		// 循环赋值
    		for (int i = 0; i < classes.length; i++) {
    			for (int j = 0; j < classes[i].length; j++) {
    			//	String strings = classes[i][j];
    				
    				if (j < 9) {
    					classes[i][j] = cousePreFix[i]  + "0" + (j + 1) + "\t";	
    				} else {
    					classes[i][j] = cousePreFix[i]   + (j + 1) + "\t";	
    				}
    				
    			}
    			// System.out.println("\n");	
    		}
    		// 循环遍历
    		for (String[] strings : classes) {
    			System.out.println(Arrays.toString(strings));
    			
    		}
	}

21：利用数组随机姓名

         @Test
		public void test16() {
				// 姓氏
				String[] surnames = new String[] {"东方","左丘", "欧阳", "皇甫", "上官", "闾丘", "令狐",
				        "夏侯", "诸葛", "尉迟", "皇甫", "宇文", "鲜于", "西门", "司马", "独孤", "公孙", "慕容", "轩辕",
				         };
				// 名字
				String[] names = new String[] {"何", "高", "梁", "郑", "罗", "宋", "谢", "唐", "韩", "曹", "许", "邓", "萧", "冯",
				        "曾", "程", "蔡", "彭", "潘", "袁", "於", "董", "余", "苏", "叶", "吕", "魏", "蒋",
				        "田", "杜", "丁", "沈", "姜", "范", "江", "傅", "钟", "卢", "汪", "戴", "崔", "任",
				        "陆", "廖", "姚", "方", "金", "邱", "夏", "谭", "韦", "贾", "邹", "石", "熊", "孟",
				        "秦", "阎", "薛", "侯", "雷", "白", "龙", "段", "郝", "孔", "邵", "史", "毛", "常",
				        "万", "顾", "赖", "武", "康", "贺", "严", "尹", "钱", "施", "牛", "洪", "龚", "李",
				        "刘", "陈", "杨", "黄", "赵", "周", "吴", "徐", "孙", "朱", "马", "胡", "郭", "林"
				        };
				Random random = new Random();
				for (int j = 0; j < 100; j++) {
					// 随机姓氏
					String surname = surnames[random.nextInt(surnames.length)];
					// 随机名字
					int count = random.nextInt(1,3);
					String name = "";
					for (int i = 0; i < count; i++) {
						name +=  names[random.nextInt(names.length)];
					}
					// 拼接姓名
					String generateName = surname + name;
					System.out.println("我的姓名 >>> " + generateName);
				}
		}

22：可变数组

/**方法参数中数据类型后的三个点代表数据类型的可变数组
*@author 刘梦博
*@version 1.0.0 2022年3月25日 下午10:29:28
*/
public class Demo01 {
   public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9};
        printArray(array);
        printArray();
        printArray(9);
        printArray(3,6);
    }
    public static void printArray(int... array) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i < array.length -1) {
                System.out.print(array[i] + ",");
            } else {
            System.out.print(array[i]);
		
		}
		System.out.println("]");
	}
}