数组的概述
内存结构的简单说明
一维数组
tel:18013820100
package com.popq.java;
/*
* 1.数组的概述：
* 1.数组的理解：数组（Array）,是多个相同类型数据按一定顺序排列的集合
* 并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
*
* 2.数组的相关概念：
* >数组名
* >元素
* >角标，下标，索引
* >数组的长度：元素的个数
*
* 3.数组的特点：
* 1.数组是有序排列的
* 2.数组属于引用数据类型变量。数组的元素既可以是基本数据类型，也可以是引用数据类型
* 3.创建数组对象会在内存中开辟一整块连续空间
* 4.数组的长度一旦确定就不能修改
*
*4.数组的分类：
* 1.按照维数：一维数组，二维数组........
* 2.按照数组元素类型：基本数据类型元素的数组，引用数据类型元素的数组
*
* 5.一维数组的使用
* 1.一维数组的声明和初始化
* 2.如何调用数组指定位置的元素
* 3.如何获取数组的长度
* 4.如何遍历数组
* 5.数组元素的默认初始化值
* 6.数组的内存解析
*
*
*/
public class ArrayTest {
public static void main(String[] args) {
// 1.一维数组的声明和初始化
int[] ids;// 声明
// 1.1静态初始化：数组的初始化和元素的赋值操作同时进行
ids = new int[] { 1001, 1002, 1003, 1004 };
// 1.2动态初始化：数组的初始化和元素的赋值操作分开进行
String[] names = new String[5];
// 总结：数组一旦初始化完成,其长度就确定了。
// 2.如何调用数组的指定位置的元素：通过索引的方式
// 数组的索引是从0开始的，到数组的长度-1结束。
names[0] = "王铭";
names[1] = "王鹤";
names[2] = "张学良";
names[3] = "孙巨龙";
names[4] = "王宏志"; // charAt(0)
// names[5] = "周洋";超出数组索引范围
// 3.如何获取数组的长度
// 属性：length
System.out.println(names.length);// 5
System.out.println(ids.length);// 4
// 4.如何遍历数组
// System.out.println(names[0]);
// System.out.println(names[1]);
// System.out.println(names[2]);
// System.out.println(names[3]);
// System.out.println(names[4]);
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
// 5.数组元素的默认初始化值
// 数组元素实整形初始化值：0
// 浮点型：0.0
// char型：0 (ascii码) 或 '\u0000' 而非 '0'
// boolean型：false
// 引用数据类型
// String型：null(空)
int[] arr = new int[4];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("##############################");
short[] arr1 = new short[4];
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
System.out.println("##############################");
float[] arr2 = new float[4];
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
System.out.println("##############################");
char[] arr3 = new char[4];
for (int i = 0; i < arr3.length; i++) {
System.out.println("----" + arr3[i] + "----");
}
System.out.println("##############################");
boolean[] arr4 = new boolean[4];
for (int i = 0; i < arr4.length; i++) {
System.out.println(arr4[i]);
}
System.out.println("##############################");
String[] arr5 = new String[4];
for (int i = 0; i < arr5.length; i++) {
System.out.println(arr5[i]);
}
// 6.数组的内存解析
}
}
package com.popq.java;
import java.util.Scanner;
/*从键盘读取学生成绩，找出最高分，并输出学生成绩等级
*
* 成绩 >= 最高分 - 10 A
* 成绩 >= 最高分 - 20 B
* 成绩 >= 最高分 - 30 C
* 其余 D
*
* 提示：先读入学生人数，根据人数创建int数组，存放学生成绩
*
*
*/
public class ArrayExer1 {
public static void main(String[] args) {
//1.使用scanner，读取学生个数
Scanner scan = new Scanner(System.in);
System.out.print("请输入学生人数：");
int studentNumber = scan.nextInt();
//2.创建数组，存储学生成绩：动态初始化
int[] scores = new int[studentNumber];
//3.给数组中的元素赋值
int maxScore = 0;
System.out.println("请输入" + studentNumber + "个成绩");
for(int i = 0;i < scores.length;i++) {
scores[i] += scan.nextInt();
//4.获取数组中元素的最大值：最高分
if(maxScore < scores[i]) {
maxScore = scores[i];
}
}
//4.获取数组中元素的最大值：最高分
// int maxScore = 0;
//
// for(int i = 0;i < scores.length;i++) {
// if(maxScore < scores[i]) {
// maxScore = scores[i];
// }
// }
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
System.out.println("最高成绩是" + maxScore);
for(int i = 0;i < scores.length;i++) {
if(scores[i] - maxScore >= -10) {
System.out.println("student " + i + " score is " + scores[i] + " grade is A");
}else if(scores[i] - maxScore >= -20) {
System.out.println("student " + i + " score is " + scores[i] + " grade is B");
}else if(scores[i] - maxScore >= -30) {
System.out.println("student " + i + " score is " + scores[i] + " grade is C");
}else {
System.out.println("student " + i + " score is " + scores[i] + " grade is D");
}
}
}
}
package com.popq.java;
public class ArrayExer {
public static void main(String[] args) {
int[] arr = new int[] { 8, 2, 1, 0, 3 };
int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
String tel = "";
for (int i = 0; i < index.length; i++) {
tel += arr[index[i]];
}
System.out.println("联系方式：" + tel);
}
}
多维数组的使用
package com.popq.java;
/*
*二维数组的使用
*
* 1.理解
* 对于二维数组的理解，我们可以看成是一堆数组array1又作为另一个数组array2的元素而存在
* 其实，从数组的底层的运作机制来看，其实没有多维数组
*
* 2.二维数组的使用：
* 1.二维数组的声明和初始化
* 2.如何调用数组指定位置的元素
* 3.如何获取数组的长度
* 4.如何遍历数组
* 5.数组元素的默认初始化值
* 规定：二维数组分为外层数组元素，内层数组元素
* 例如：int arr = new int[4][3]
* 外层元素：arr[0],arr[1]等
* 内层元素：arr[0][0],arr[1][1]等
* 针对初始化方式1：比如 int[][] arr = new [3][4];
* 外层元素的初始化值为：地址值
* 内层元素的初始化值为：与一位数组的初始化结果相同
* 针对初始化方式2：比如 int[][] arr = new int[4][];
* 外层元素初始化值为：null
* 内层元素的初始化值为：不能调用，否则报错
*
* 6.数组的内存解析
*
*
*
*
*
*
*/
public class ArrayTest1 {
public static void main(String[] args) {
// 1.二维数组的声明和初始化
// int[] arr = new int[]{1,2,3};
// 二维数组的静态初始化
int[][] arr = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
// 二维数组的动态初始化1
String[][] arr1 = new String[3][2];
// 二维数组的动态初始化2
String[][] arr2 = new String[3][];
// 2.如何调用二维数组的指定位置元素
System.out.println(arr[0][1]);// 2
System.out.println(arr1[2][1]);// null
// System.out.println(arr2[1][1]);//java.lang.NullPointerException
arr2[1] = new String[4];
System.out.println(arr2[1][1]);
// 3.获取二维数组的长度
System.out.println(arr.length);// 3
System.out.println(arr[0].length);// 3
// 如何遍历二维数组
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
// 5.数组元素的默认初始化值
int[][] arr4 = new int[4][3];
System.out.println(arr4[0]);// 地址值[I@606d8acf
System.out.println(arr4[0][0]);// 0
System.out.println(arr4);// 地址值[[I@782830e
float[][] arr5 = new float[3][4];
System.out.println(arr5);// 地址值
System.out.println(arr5[0][0]);// 0.0
String[][] arr6 = new String[4][];
System.out.println(arr6);// 地址值[[Ljava.lang.String;@5fdef03a
System.out.println(arr6[2]);// null
}
}
二维数组练习
package com.popq.exer;
/*
* 使用二維數組打印一個10行的楊輝三角
*
* 提示
* 1.第一行有一個元素，第N行有N個元素
* 2.每一行的第一個元素和最後一個元素都是1
* 3.從第三行開始，對於非第一個元素和最後一個元素。即
* yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
*
* 拓展筆試題
* 創建一個長度為6的int型數據，要求數組元素的值都在1-30之間，且都是隨即賦值。
* 同時，要求元素的值各不相同
*
*/
public class YangHuiExer {
public static void main(String[] args) {
//1.聲明並初始化二維數組
int[][] yangHui = new int[10][];
//2.給數組賦值
for(int i = 0;i < yangHui.length;i++) {
yangHui[i] = new int[i + 1];
//2.1給首末元素賦值
yangHui[i][0] = yangHui[i][i] = 1;
//2.2給每行非首末元素賦值
if(i > 1) {
for(int j = 1;j < yangHui[i].length - 1;j++) {
yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
}
}
}
//3.遍歷二維數組
for(int i = 0;i < yangHui.length;i++) {
for(int j = 0;j < yangHui[i].length;j++) {
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
}
}
算法
Arrays工具类的使用
package com.popq.arithmetic;
/*
*算法的考察 ：數組的複製，反轉，查找（綫性查找，二分法查找）
*
*
*/
public class ArithmeticTest {
public static void main(String[] args) {
String[] arr = new String[] { "JJ", "DD", "MM", "GG", "AA", "BB" };
// 1.數組的複製(區別於數組變量的賦值:arr1 = arr)
String[] arr1 = new String[arr.length];
for (int i = 0; i < arr.length; i++) {
arr1[i] = arr[i];
System.out.print(arr1[i] + " ");
}
System.out.println();
// 2.數組的反轉
// 方式1
// for(int i = 0;i < arr.length / 2;i++) {
// String temp = arr[i];
// arr[i] = arr[arr.length - i - 1];
// arr[arr.length - i - 1] = temp;
// }
// System.out.println();
//
// //遍歷
// for(int i = 0;i < arr.length;i++) {
// System.out.print(arr[i] + " ");
// }
// 方法2
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 遍歷
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
// 3.查找（搜索）
// 綫性查找：
String dest = "GG";
boolean isFind = true;
for (int i = 0; i < arr.length; i++) {
if (dest.equals(arr[i])) {
System.out.println("找到了指定的元素，位置為" + i);
isFind = false;
break;
}
}
if (isFind) {
System.out.println("不好意思沒找到");
}
// 3.1二分法查找（折半查找）
// 前提：索要查找的數組必須是有序的
int[] arr2 = new int[] { -98, -32, 5, 23, 89, 101, 111, 456, 985 };
int dest1 = 1111;
int head = 0;// 初始的首索引
int end = arr2.length - 1;// 出事的尾索引
boolean isFlag = true;
while (head <= end) {
int middle = (head + end) / 2;
if (dest1 == arr2[middle]) {
System.out.println("找到了指定元素，位置為" + middle);
isFlag = false;
break;
} else if (dest1 < arr2[middle]) {
end = middle - 1;
} else {
head = middle + 1;
}
}
if (isFlag) {
System.out.println("不好意思沒找到你想要找的元素。");
}
}
}
package com.popq.arithmetic;
/*
* 使用簡單數組
* 1.創建一個名爲ArrayTest的類，在main()方法中聲明array1和array2兩個變量,他們是
* int[]類型的數組
*
* 2.使用大括號{},吧array1初始化為8個元素:2,3,5,7,11,13,17,19.
*
* 3.顯示array1的内容
*
* 4.賦值array2變量等於array1,修改array2中的偶元素引元素，使其等於索引值
* (如array[0] = 0,array[2] = 2),打印出array1
*
* 思考：array1 和 array2是什麽關係？ arr1和arr2地址相同,都指向了堆空間的唯一的一個數組實體
* 拓展：修改題目，實現array2對array1的數組的複製
*
*
* */
public class ArithmeticExer2 {
public static void main(String[] args) {
int[] arr1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
int[] arr2 = new int[8];
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
// 數組的賦值
arr2 = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
System.out.println();
// 修改array2中的偶元素引元素，使其等於索引值(如array[0] = 0,array[2] = 2)
for (int i = 0; i < arr2.length; i++) {
if (i % 2 == 0) {
arr2[i] = i;
}
}
// 打印出arr1
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
}
}
package com.popq.arithmetic;
/*
* 使用簡單數組
* 1.創建一個名爲ArrayTest的類，在main()方法中聲明array1和array2兩個變量,他們是
* int[]類型的數組
*
* 2.使用大括號{},吧array1初始化為8個元素:2,3,5,7,11,13,17,19.
*
* 3.顯示array1的内容
*
* 4.賦值array2變量等於array1,修改array2中的偶元素引元素，使其等於索引值
* (如array[0] = 0,array[2] = 2),打印出array1
*
* 思考：array1 和 array2是什麽關係？ arr1和arr2地址相同,都指向了堆空間的唯一的一個數組實體
* 拓展：修改題目，實現array2對array1的數組的複製
*
*
* */
public class ArithmeticExer1 {
public static void main(String[] args) {
int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
int[] arr2 = new int[8];
for(int i = 0;i < arr1.length;i++) {
System.out.print(arr1[i] + " ");
}
arr2 = arr1;//不能稱作數組的複製
System.out.println();
//修改array2中的偶元素引元素，使其等於索引值(如array[0] = 0,array[2] = 2)
for(int i = 0;i < arr2.length;i++) {
if(i % 2 == 0) {
arr2[i] = i;
}
}
//打印出arr1
for(int i = 0;i < arr1.length;i++) {
System.out.print(arr1[i] + " ");
}
}
}
package com.popq.arithmetic;
/*
* 算法的考察：求數值型數組中元素的最大值，最小值，平均值
*
* 定義一個Int型的一維數組，包含10個元素，分別賦一些隨機整數
* 然後求出所有元素的最大值，最小值，和值，平均值，並數出來
* 要求所有隨機數都是兩位數
*
* [10,99]隨機數
*
* 公式(int)(Math.random() * (99 - 10 + 1) + 10)
*
*
*/
public class ArithmeticExer {
public static void main(String[] args) {
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * (99 - 10 + 1) + 10);
}
// 最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
System.out.println("最大值是：" + max);
// 最小值
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
System.out.println("最小值是：" + min);
// 和值
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("和值是：" + sum);
// 平均值
System.out.println("平均值是：" + (double) sum / arr.length);
}
}
冒泡排序
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwymYXpD-1634106879014)(:/3e1fd84249174bc39a87a69644c5e958)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e5CaaViZ-1634106879016)(:/034cad40de9c4863b2123c81f2a4b297)]
/*
* 数组的冒泡排序的实现
*
*
*
*/
package com.popq.arithmetic;
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[] {43,32,76,-98,0,64,33,-22,32,99};
//冒泡排序
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]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i]);
}
}
}
快速排序
数组中的常见异常
package com.popq.Arrays;
/*
* 数组中的常见异常
* 1.数组角标越界的异常：ArrayIndexOutOfBoundsException
* 2.空指针异常：NullPointerException
* 3.
*
*
*/
public class ArrayExceptionTest {
public static void main(String[] args) {
//1.数组角标越界的异常：ArrayIndexOutOfBoundsException
int[] arr1 = new int[] {1,2,3,4,5};
for(int i = 0;i < arr1.length;i++) {
System.out.println(arr1[i]);
}
//2.空指针异常：NullPointerException
//情况一：
// int[] arr2 = new int[] {1,2,3};
// arr2 = null;
// System.out.println(arr2[0]);
//情况二：
// int[][] arr3 = new int[4][];
// System.out.println(arr3[0][0]);
//情况三：
String[] arr3 = new String[] {null,"bb","cc"};
System.out.println(arr3[0].toString());
}
}
820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
