文章目录
数组
动态初始化1（直接声明和分配）
动态初始化2（先声明再分配）
静态初始化
数组细节(⭐⭐⭐)
数组赋值机制(⭐⭐⭐)
打印数组最大值的下标
数组拷贝
数组反转
数组添加/扩容
冒泡排序
顺序查找(⭐⭐⭐)
二维数组
动态初始化
静态初始化
细节
数组
引出数组
假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
传统方法：
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/14:02 */ public class demo21 { public static void main(String[] args) { //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？ int a = 112; int b = 122; int c = 212; int d = 212; int e = 312; int f = 142; System.out.println("总重量是："+(a+b+c+d+e+f)+"kg"); } }
结果：总重量是：1112kg
思考：我们发现6只佩奇都是int类型的，而我们却要定义6个变量，有没有更好的处理方案呢–》引入数组
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型
使用数组解决上面需求：
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/14:02 */ public class demo21 { public static void main(String[] args) { //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？ int[] pig = {112,122,212,212,312,142}; int sum = 0; for (int i = 0; i < pig.length; i++) { sum += pig[i]; } System.out.println("总重量是："+sum+"kg"); } }
动态初始化1（直接声明和分配）
数组的定义
数据类型 数组名[] = new 数据类型[大小];
int[] a = new int[5];
创建了一个数组，名字为a，存放5个int类型大小
数组的使用
数组名[下标名/索引/index]
访问数组a的第3个元素 a[2];
数组下标是从0开始计数的
import java.util.Scanner; public class xunhuan { public static void main(String[] args) { //创建数组，double，大小5 double[] scores = new double[5]; //循环输入 for (int i = 0; i < scores.length; i++) { System.out.println("请输入第"+(i+1)+"个数据的值"); Scanner scanner = new Scanner(System.in); scores[i] = Double.parseDouble(scanner.nextLine()); } int sum = 0; for (int i = 0; i < scores.length; i++) { sum+=scores[i]; } System.out.println("综合为："+sum+" 平均分是:"+sum/5); } }
动态初始化2（先声明再分配）
先声明数组
语法：数据类型[] 数组名； 或 数据类型 数组名[];
举例：int a[]; 或 int[] a;
创建数组
语法：数组名 = new 数据类型[大小];
举例：a = new int[10];
double scores[];//声明数组，这时scores是null scores = new double[5];//分配内存空间，可以存放数据
静态初始化
语法：数据类型 数组名[] = {元素值，元素值1，……};
举例：int a[] = {1,2,5,6,9,0};
如果知道数组有多少元素，具体的值就可以使用静态初始化
相当于：int a[] = new int[6];
a[0] = 1;
a[1] = 2;
a[2] = 5;
a[3] = 6;
a[4] = 9;
a[5] = 0;
数组细节(⭐⭐⭐)
数组是多种相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以创建任意的数据类型，包括基本类型和引用类型，但是不能混合使用
数组创建后，如果没有赋值，有默认值，int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000, boolean flase,String null
使用数组的步骤，1，声明数组并开辟空间 2，给数组各元素赋值 3，使用
数组下标是从0开始的
数组下标必须在指定的范围内使用。否则就会出现 数组下标越界的异常
数组属于引用类型。数据类型是对象（object）
数组赋值机制(⭐⭐⭐)
基本数据类型赋值，值传递
public class demo14 { public static void main(String[] args) { int n1 = 10; int n2 = n1; n2 = 80; System.out.println("n1="+n1); System.out.println("n2="+n2); } }
值拷贝,n2不会影响n1
结果：
n1=10
n2=80
引用类型赋值传递的是地址
引用传递，是一个地址
public class demo14 { public static void main(String[] args) { int[] arr1 = {1,2,3}; int[] arr2 = arr1;//把arr1赋值给arr2 arr2[0] = 10; System.out.println(arr1[0]); } }
这里改变的是arr2的值，发现arr1的值也被改变
输出：10
打印数组最大值的下标
重点学习下标的获取，学会随着需求的驱动去定义变量，从而解决问题，体现在int maxIndex = 0; //记录下标
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/14:02 */ public class demo21 { public static void main(String[] args) { //找出数组最大值的下标，并打印出来 int[] arr = {1, 345, 45, 800, 666}; int max = arr[0];//假定第一个元素是最大值 int maxIndex = 0; //记录下标 for (int i = 1; i < arr.length; i++) {//从下标 1 开始遍历 arr if (max < arr[i]) {//如果 max < 当前元素 max = arr[i]; //把 max 设置成 当前元素 maxIndex = i; } } System.out.println("最大值的下标为：" + maxIndex); } }
数组拷贝
编写代码 实现数组拷贝(内容复制)
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/15:28 */ public class demo22 { //编写代码 实现数组拷贝(内容复制) public static void main(String[] args) { int arr1[] = {1,2,3,4,5};//原数组 int arr2[] = new int[arr1.length];//新数组，赋值后的数组，长度为 arr1.length //这时的arr2数组，里有默认值0，通过循环把arr1中的每个元素赋值给arr2，即完成复制 for (int i = 0; i < arr1.length; i++) { arr2[i] = arr1[i]; } //输出两个数组 System.out.println("arr1====复制====arr2\n"); for (int i = 0; i < arr1.length; i++) { System.out.print("arr1: "+arr1[i]+"\t\t"); System.out.println("arr2: "+arr2[i]); } //改变arr1中元素的值，再输出 System.out.println("\narr1====改变arr1后======arr2\n"); arr1[2] = 100; for (int i = 0; i < arr1.length; i++) { System.out.print("arr1: "+arr1[i]+"\t\t"); System.out.println("arr2: "+arr2[i]); } } }
数组反转
方案1：
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/16:28 */ public class demo23 { //要求：把数组的元素内容反转 public static void main(String[] args) { int arr[] = {1,2,3,4,5}; int temp = 0; int len = arr.length; for (int i = 0; i < len/2; i++) { temp = arr[len - 1 - i]; arr[len - 1 - i] = arr[i]; arr[i] = temp; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]); } } }
方案2：逆序赋值(⭐⭐⭐)
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/17:32 */ public class demo24 { public static void main(String[] args) { int[] arr1 = {1, 2, 3, 4, 5}; int[] arr2 = new int[arr1.length]; for (int i = arr1.length - 1, j = 0; i >= 0; i--, j++) { arr2[j] = arr1[i]; } System.out.println("前arr1："+arr1.hashCode()); System.out.println("前arr2："+arr2.hashCode()); arr1 = arr2; System.out.println("后arr1："+arr1.hashCode()); System.out.println("后arr2："+arr2.hashCode()); for (int i = 0; i < arr2.length; i++) { System.out.println(arr1[i]); } } }
输出：
前arr1：22307196 前arr2：10568834 后arr1：10568834 后arr2：10568834 5 4 3 2 1
数组添加/扩容
定义一个新数组，遍历原数组把原数组拷贝给新数组，处理新元素，将新数组的地址指向旧数组，即完成数组的扩容
import java.util.Scanner; /** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/17:56 */ public class demo25 { //数组扩容 public static void main(String[] args) { String[] arr = {"唐三", "小舞", "唐浩", "阿银"}; Scanner scanner = new Scanner(System.in); boolean loop = true; do { System.out.print("输入要添加的名字："); String name = scanner.next(); String[] strings = new String[arr.length + 1]; for (int i = 0; i < arr.length; i++) { strings[i] = arr[i]; strings[strings.length - 1] = name; } arr = strings; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } System.out.println("输入n退出"); String k = scanner.next(); if (k.equals("n")) { loop = false; } } while (loop); } }
冒泡排序
外层循环决定多少轮，一轮确定一个最大值或最小值，内层循环实现比较和调换
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/20:30 */ public class demo26 { //冒泡排序 public static void main(String[] args) { int[] arr = {23, 45, 11, 22, 89, 0, 76, 81}; int temp = 0; for (int i = 0; i < arr.length; i++) { System.out.print(" " + arr[i]); } for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] < arr[j + 1]) { temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } System.out.println("\n============冒泡排序后============"); for (int i = 0; i < arr.length; i++) { System.out.print(" " + arr[i]); } } }
顺序查找(⭐⭐⭐)
在 java 中，我们常用的查找有两：
顺序查找
二分查找
有一个数列，从键盘中任意输入一个名称，判断数列中是否包含此名称，要求: 如果找到了，就提示找到，并给出下标值。没有找到，提示
注意：这里的判断处理，技巧你 get 了吗？
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/20:59 */ public class demo27 { //有一个数列,从键盘中任意输入一个名称,判断数列中是否包含此名称 // 要求: 如果找到了，就提示找到，并给出下标值。没找到，提示 public static void main(String[] args) { String name[] = {"小张","狗蛋","李白","王昭君","苏妲己","西施"}; int index = -2; Scanner scanner = new Scanner(System.in); System.out.print("搜索："); String sName = scanner.next(); for (int i = 0; i < name.length; i++) { if(sName.equals(name[i])){ index = i; System.out.println("下标为："+i+" "+name[i]); break; } } if(index == -2){ System.out.println("没找到"); } } }
二维数组
就是套娃，数组的元素又是一个数组
用二维数组输出如下图形 1 0 0 0 0 0 0 2 0 0 0 0 0 2 3 0 0 0 0 0 0 4 0 0
/** * @Author: liu sen * @Version: 1.0 * @Date: 2021/08/31/21:27 */ public class demo28 { public static void main(String[] args) { //二维数组定义 int[][] arr = { {1, 0, 0, 0, 0, 0}, {0, 2, 0, 0, 0, 0}, {0, 2, 3, 0, 0, 0}, {0, 0, 0, 4, 0, 0}}; int[][] arr1 = new int[4][5]; arr1[0][0] = 1; arr1[1][1] = 2; //二维数组打印 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j]+" "); } System.out.println(); } System.out.println("==============="); for (int i = 0; i < arr1.length; i++) { for (int j = 0; j < arr1[i].length; j++) { System.out.print(arr1[i][j]+" "); } System.out.println(); } } }
运行：
1 0 0 0 0 0 0 2 0 0 0 0 0 2 3 0 0 0 0 0 0 4 0 0 =============== 1 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0
动态初始化
1) 语法: 类型[][] 数组名=new 类型[大小][大小] 2) 例子: int a[][]=new int[2][3]
先声明：类型 数组名[][]; 再定义(开辟空间) 数组名 = new 类型[大小][大小] 赋值(有默认值，比如 int 类型的就是 0
静态初始化
定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}} 使用即固定方式访问
细节
一维数组的声明方式有:int[] x 或者 int x[]
二维数组的声明方式有:int[][] y 或者 int[] y[] 或者 int y[][]
二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如： map[][] 是一个二维数组int map [][] = {{1,2},{3,4,5}}由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，也称为列数不等的二维数组
