知识点：
一维数组 冒泡排序 Arrays.toString/sort()/copyOf()
一、数组
1.1 概念
数组 Array，标志是[ ] ,用于储存多个相同类型数据的集合
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从 0 开始的,下标的最大值是数组的长度减 1
1.2 创建数组
数组的创建方式一般分为动态初始化和静态初始化
//1. 动态初始化
int [] a = new int [5];
//2. 静态初始化
int [] b = new int []{1,2,3,4,5};
int [] c = {1,2,3,4,5};
1.3 创建数组过程分析
程序创建数组 int[] a = new int[5]; 时发生了什么?
1. 在内存中开辟连续的空间,用来存放数据,长度是 5
2. 给数组完成初始化过程,给每个元素赋予默认值,int 类型默认值是 0
3. 数组完成初始化会分配一个唯一的地址值
4. 把唯一的地址值交给引用类型的变量 a 去保存
TIPS: 数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据
1.4 练习 1：向数组中存入数据 hello
创建类: Test1_CreateArray.java
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:08:20
*/
/**本类用于测试数组的创建,将hello存入到数组中*/
public class Test1_CreateArray {
public static void main(String[] args) {
//1.创建数组
//1.1静态创建--已经知道了数组中的具体数据
char[] a = {'h','e','l','l','o'};
System.out.println(a);
char[] b = new char[] {'h','e','l','l','o'};
System.out.println(b);
//1.2动态创建--知道数组的长度,后期加内容
char[] c = new char[5];//在内存中开辟一块连续的内存空间,用于存放5个字符
//通过数组下标操作数组
//数组下标从0开始,数组的最大下标是数组的长度-1
c[0]='h';//给数组中的第1个元素赋值
c[1]='e';//给数组中的第2个元素赋值
c[2]='l';//给数组中的第3个元素赋值
c[3]='l';//给数组中的第4个元素赋值
c[4]='o';//给数组中的第5个元素赋值
System.out.println(c);
//char类型底层做了特殊处理,可以直接打印数组中的元素
//其他类型的数组想要打印数组中的元素,需要借助数组的工具类Arrays.toString()
//1.3创建一个String类型的数组
String[] s = {"a","b","c"};
System.out.println(s);//[Ljava.lang.String;@15db9742
System.out.println(Arrays.toString(s));//[a, b, c]
}
}1.5 数组的长度
数组的长度用 length 属性来表示,数组一旦创建，长度不可改变,数组的长度允许为 0
//2. 获取数组的长度
System. out .println( "c 数组的长度为 :" + c . length );
System. out .println( "c2 数组的长度为 :" + c2 . length );
System. out .println( "c3 数组的长度为 :" + c3 . length );
1.6 数组的遍历
遍历:从头到尾，依次访问数组每一个位置,获取每一个位置的元素。 形式如下:
for( 从下标为 0 的位置开始 ; 下标的取值 <= 数组的长度 -1; 下标 ++){
循环体;
}
1.7 练习 2-1：输出每个月的天数
创建类: Test2_ArrayExec.java
package cn.mbh.array;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:19:37
*/
/**本类用于练习数组的遍历*/
public class Test2_ArrayExec {
public static void main(String[] args) {
//本方法用于输出每个月的天数
method();
}
//需求:例如,打印 1月有31天
public static void method() {
//1.创建数组用来存12个月的天数
int[] a = {31,29,31,30,31,30,31,31,30,31,30,31};
//2.输出每个月的天数,打印到控制台
//数组的遍历--通过循环的方式--通过数组中元素的下标来操作
//循环开始:a[0] -- 数组中的第一个元素
//循环结束:a[a.length-1] -- 数组中的最后一个元素
//循环变化:++
for (int i = 0; i < a.length-1; i++) {
//a[i]--根据下标i来获取a数组中对应位置元素的值
System.out.println((i+1)+"月有:"+a[i]+"天");
}
}
}1.8 练习 2-2：遍历数组，存入 1 到 10
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:19:37
*/
/**本类用于练习数组的遍历*/
public class Test2_ArrayExec {
public static void main(String[] args) {
method2();
}
//需求:遍历数组,存入1-10
public static void method2() {
//1.创建数组--动态创建
int[] a = new int[10];
//2.遍历数组,依次给每个位置赋值
//循环开始:a[0] -- 数组中的第一个元素
//循环结束:a[a.length-1] -- 数组中的最后一个元素
//循环变化:++
for(int i = 0 ;i<=a.length-1 ;i++) {
//a[i]--根据下标i来操作a数组对应下标的元素
a[i]=i+1; //i的初始值是0,取值范围是0-9,所以要+1变成1-10
}
//3.在存入10个数据之后,打印a数组
//char类型在底层做了处理,除它之外的类型的数组想要获取数组的具体元素
//需要借助Arrays.toString(数组名)打印数组的具体内容
//System.out.println(a);//[I@15db9742
System.out.println(Arrays.toString(a));
}
}
}1.9 练习 2-3：创建随机数组
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:19:37
*/
/**本类用于练习数组的遍历*/
public class Test2_ArrayExec {
public static void main(String[] args) {
// 创建method3()
method3();
}
public static void method3() {
// 1.创建数组--动态
int[] a = new int[10];
// 2、遍历数组，给元素赋值
// int i = 0 是指从下标为0的位置开始
// i < a.length 是指下标最大值是数组的长度-1
// i++ 是指下标自增
for (int i = 0; i < a.length; i++) {
// a[i]是指根据下标获取元素 ，赋予100以内的随机数
a[i] = new Random().nextInt(100);
}
// 3.打印数组中的元素
System.out.println(a);// [I@6d06d69c
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Arrays是数组的工具类，toString(m) - m是要把哪个数组的元素显示成一个字符串
System.out.println(Arrays.toString(a));
}
}
}二、冒泡排序 bubble
2.1 概念
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列， 依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从 A 到 Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸 饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
2.2 形式
相邻位置比较，从小到大排序，如果小就往前换。
i 代表从头到尾遍历循环数据
2.3 练习 3：实现冒泡排序
创建类: Test3_ Bubble.java
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:44:55
*/
/**这个类用来测试冒泡排序算法:27,96,73,25,21*/
public class Test3_Bubble {
public static void main(String[] args) {
//1、创建无序数组
int[] a = {27,96,73,25,21};
//2、调用method()排序
int[] newA = method(a);
System.out.println("排序完毕:"+Arrays.toString(newA));
}
//完成排序
public static int[] method(int[] a) {
//1、外循环：控制比较轮数，假设n个数，需要比较n-1次
//a.length-1 是指需要比较的轮数是数组的长度-1
for (int i = 0; i < a.length-1; i++) {
//2、内循环：相邻比较 交换位置
//a.length-1 是指每轮比较时都会冒出来最大数，并且不会再次参与比较
System.out.println("第"+(i+1)+"轮:");
for (int j = 0; j < a.length-1; j++) {
//相邻元素的值比较，a[j]代表的是前一个元素，a[j+1]代表的是后一个元素
if (a[j] > a[j+1]) {
//交换数据
int t = a[j];
a[j]=a[j+1];
a[j+1]=t;
}
System.out.println("第"+(j+1)+"次:"+Arrays.toString(a));
}
System.out.println("第"+(i+1)+"轮结果:"+Arrays.toString(a));
}
return a;//把排序后的数组返回
}
}三、数组工具类 Arrays
3.1 Arrays.toString(数组)
把数组里的数据，用逗号连接成一个字符串。[值 1,值 2]
3.2 Arrays.sort(数组)
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。
3.3 练习 4：练习 Arrays.sort(数组)
注意是在原数组的基础上直接排序好,不创建新数组
创建类: Test4_ArraysSort.java
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:55:40
*/
/**测试数组工具类Arrays*/
public class Test4_ArraySort {
public static void main(String[] args) {
//1、创建无序数组
int[] a = {21,96,75,23,25};
//底层使用的排序算法是：经过优化后的快速排序算法
Arrays.sort(a);//对无序数组进行排序
System.out.println(Arrays.toString(a));
}
}3.4 Arrays.copyOf(数组，新的长度)
把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置
新数组长度小于原数组，相当于截取前一部分数据
3.5 练习 5：练习 Arrays. copyOf(数组，新的长度)
创建类: Test5_ArraysCopyOf.java
package cn.mbh.array;
import java.util.Arrays;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午3:59:06
*/
/**本类用于测试数组工具类Arrays*/
//Arrays.copyOf()不是改变原数组,而是创建一个新的数组
//copyOf(m,n)--n的长度大于m数组的长度,是扩容;n小于m数组的长度是缩容
public class Test5_ArrayCopyOf {
public static void main(String[] args) {
//1.创建一个无序数组
int[] a = {21,96,75,23,25};
//2.使用工具类方法进行数组数据排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//3.Arrays.copyOf(数组,新的长度)
//3.1复制数组
int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
int[] to =Arrays.copyOf(from, 5);//需要复制哪个数组.复制的长度
System.out.println(Arrays.toString(to));
//3.2数组的扩容
//先创建对应长度的新数组,然后复制原数组的数据,不足的即为默认值,此处int[]默认值是0
int[] to2=Arrays.copyOf(from, 10);
System.out.println(Arrays.toString(to2));
//3.3数组的缩容
//先创建对应长度的新数组,然后按照参数个数复制原数组的数据
int[] to3=Arrays.copyOf(from, 3);
System.out.println(Arrays.toString(to3));
}
}四、二维数组
4.1 概念
存放数组的数组，也就是说数组里存的还是数组的数据形式。
4.2 创建二维数组
int[][] a = {{1, 3},{4, 6},{7, 9}};
--创建外部数组，长度是3
--给每个外部数组的位置，创建内部数组，每个内部数组长度是2
--给每个内部数据初始化
--给二维数组生成唯一的地址值
--把地址值交给引用类型变量a保存
4.3 遍历二位数组
for(int i=0;i<a.length;i++){//遍历外部数组
for(int j=0;j<a[i].length;j++){//遍历内部数组
System.out.println(a[i][j]);
}
}
4.4 练习 6：打印二维数组中的数据
创建类: Test6_Arrays2.java
package cn.mbh.array;
/**
*@author MBH:
*@version 创建时间：2022年7月3日 下午4:06:20
*/
/**本类用于打印二维数组中的数据*/
public class Test6_Arrays2 {
public static void main(String[] args) {
//1.创建二维数组
//a[1][1] a[1][2] a[1][3]
//1 3 4
//a[2][1] a[2][2]
//4 6
int[][] a = {{1,3,4},{4,6},{7,9,9,8,0}};
for(int i =0; i<a.length;i++) {
for(int j=0;j<a[i].length;j++) {
//a[i][j] --根据外部数组的下标和内部数组的下标定位具体的元素
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
