今日语录：见识，见识，有见有识。
一、一维数组
-
概念
数组Array，是多个相同类型数据按照已定的顺序排列的集合，并使用一个名字命名，通过编号的方式对这些数据进行统一的管理。
-
常见描述
数组名
下标（索引）
元素
数组的长度
-
数组的特点
1 数组是序排列的
2 数组属于引用数据类型的变量，数组的元素，既可以是基本数据类型，也可以是引用数据类型
3 创建数组对象会在内存中开辟一块连续的空间
4 数组的长度一旦确定，就不能修改
-
数组的分类
1 照维数，一维数组，二维数组。。。
2 照数组元素的类型，基本数据类型元素的数组、引用数据类型的数组
-
一维数组的使用
使用示例
-
//1一维数组的声明和初始化
int num; //声明
num = 10; //初始化
int id = 1001;//声明+初始化
int[] ids;//声明
//静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[] {1001,1002,1003};
//动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//错误的写法
// int[] arr1 = new int[];
// int[5] arr2 = new int[5];
// int[] arr3 = new int[3]{1,2,3};
//总结：数组一旦初始化成功了，其长度就确定了；
// 2如何调用数组的指定位置的元素：通过角标（索引方式调用
// 数组的角标（索引从0开始，到数组的长度-1结束
names[0] = "王1";
names[1] = "王2";
names[2] = "王3";
names[3] = "王4";
names[4] = "王5";
//3)数组的长度如何获取：length
System.out.println(names.length); //输出5
//4)如何遍历数组
if(names.length > 0) {
for(int i = 0;i<names.length;i++) {
System.out.println(names[i]);
}
}
//5)数组的默认初始化值
// ***int型 数组的默认初始化值 ***:0
***short型 数组的默认初始化值 ***:0
***long型 数组的默认初始化值 ***:0
***double型 数组的默认初始化值 ***:0.0
***float型 数组的默认初始化值 ***:0.0
***char型 数组的默认初始化值 ***:
***boolean型 数组的默认初始化值 ***:false
***String型 数组的默认初始化值 ***:null
int[] arr = new int[4];
System.out.println(arr[0]);
System.out.println("******************arr结束****************");
short[] shortArr = new short[4];
System.out.println(shortArr[0]);
System.out.println("****************shortArr结束******************");
long[] longArr = new long[4];
System.out.println(longArr[0]);
System.out.println("*****************longArr结束*****************");
double[] doubleArr = new double[4];
System.out.println(doubleArr[0]);
System.out.println("****************doubleArr结束******************");
float[] floatArr = new float[4];
System.out.println(floatArr[0]);
System.out.println("****************floatArr结束******************");
char[] charArr = new char[4];
System.out.println(charArr[0]);
System.out.println("*****************charArr结束*****************");
boolean[] booleanArr = new boolean[4];
System.out.println(booleanArr[0]);
System.out.println("*****************booleanArr结束*****************");
String[] strArr = new String[4];
System.out.println(strArr[0]);
System.out.println("*****************strArr结束*****************");
//6)数组在内存中的解析：
6 数组的内存解析
-
数组声明方式
1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
int[] ids; //声明
ids = new int[] {1001,1002,1003};2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5]; -
特别说明
1、数组是多个相同类型数据的组合，实现对这些数据的统一管理
2、数组中的元素可以是任何数据类型，包括基本数据类型和引用类型，但不能混用
3、数组创建后，如果没有复制，有默认值
***int型 数组的默认初始化值 ***:0
***short型 数组的默认初始化值 ***:0
***long型 数组的默认初始化值 ***:0
***double型 数组的默认初始化值 ***:0.0
***float型 数组的默认初始化值 ***:0.0
***char型 数组的默认初始化值 ***:
***boolean型 数组的默认初始化值 ***:false
***String型 数组的默认初始化值 ***:null4、使用数组的步骤：
1、声明数组并开辟空间
2、给数组各个元素赋值
3、使用数组
5、数组的下标是从0开始的。
6、数组下标必须在指定范围内使用，否则报：下标越界异常，比如：int[] arr = new int[5];则有效下标值范围为： 0-4，超过则报数组下标越界异常
7、数组属于引用类型，数组型数据是对象（object）
8、数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
-
典型例题：数组反转
/**
*将数组 {11,22,33,44,55,66,77,88}
反转成 {88,77,66,55,44,33,22,11}
*/
public class ArrayTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = {11,22,33,44,55,66,77,88};
//方案一
for(int i=0;i<arr1.length/2;i++){
int temp = arr1[arr1.length-(i+1)];
arr1[arr1.length-(i+1)] = arr1[i];
arr1[i] = temp;
}
for(int i=0;i<arr1.length;i++) {
System.out.println(arr1[i]+"");
}
System.out.println("-----------------------------------------------");
// 方案二
int[] arr3 = {11,22,33,44,55,66,77,88};
int[] arr2 = new int[arr1.length];
for(int i=0;i<arr3.length;i++){
int temp = arr3[arr3.length-(i+1)];
arr2[i]=temp;
}
for(int i=0;i<arr2.length;i++) {
System.out.println(arr2[i]+"");
}
}
} -
数组扩容
2、二维数组
理解
对于二维数组的理解，我们可以看做是一维数组 array1 又作为另一个一维数组 array2 的元素存在，其实从数组底层的运行机制来看，其实没多维数组的概念。
-
二维数组的使用
// 1、二维数组的声明和初始化
int[] arr = new int[] {1,2,3};
//2、静态初始化
int[][] arr2 = new int[][] {{1,2},{2,3,4},{5,6}};
//3、动态初始化
String[][] arr3 = new String[3][2];
// 4、动态初始化2
String[][] arr4 = new String[3][];
// 3 种错误情况
// String[][] arr5 = new String[][2];
// int[5] arr6 = new int[5];
// int[] ayy7 = new int[3]{1,2,3};
// 2、如何调用数组指定位置的元素值
System.out.println(arr2[1][2]); //4
System.out.println(arr2[2][0]); //5
//3、获取数组长度
System.out.println(arr2.length);//3
System.out.println(arr3.length);//3
//4、如何遍历二维数组
for(int i=0;i<arr2.length;i++) {
for(int j=0;j<arr2[i].length;j++) {
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
System.out.println("------------------int型二维数组默认值为0------------------");
//5、二维数组元素的默认值
int[][] arrA = new int[4][3];
System.out.println(arrA[2][1]);
System.out.println("--------------------short型二维数组默认值---------------------------------");
Short[][] arrS = new Short[3][3];
System.out.println(arrS[2][1]);
System.out.println("----------------------String类型二维数组默认值---------------------------");
String[][] arrString = new String[4][4];
System.out.println(arrString[1][1]);
System.out.println("----------------------double型二维数组默认值------------------------");
double[][] arrD = new double[6][3];
System.out.println(arrD[1][1]);运行结果：
三、多维数组典型例题
杨辉三角
练习
使用二维数组打印一个10行的杨辉三角
提示：
1、第一行有1个元素，第n行有n个元素
2、每一行的第一个元素和最后一个元素都是1
3、从第三行开始，对于非第一个元素和最后一个元素的元素。即：
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
练习
使用二维数组打印一个10行的杨辉三角
提示：
1、第一行有1个元素，第n行有n个元素
2、每一行的第一个元素和最后一个元素都是1
3、从第三行开始，对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
public class ArrayTest02 {
public static void main(String[] args) {
//1、二维数组的声明与初始化
int[][] arr = new int[10][];
//2、遍历数组
for(int i = 0;i<arr.length;i++) {
arr[i] = new int[i+1];
//2.1 给数组首元素赋值
arr[i][0] =1;
//2.2 从第三行开始（i>=2），给每行的非首末元素赋值
if(i > 1) {
for(int j = 1;j<arr[i].length-1;j++) {
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
//2.3 给每行的末元素赋值
arr[i][i] = 1;
}
//3、输出杨辉三角
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();
}
}
}
运行结果：
随机赋值
练习
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值，同时要求元素的
值各不相同。
public class ArrayTest02 {
public static void main(String[] args) {
Random r = new Random();
int[] randomnumber = new int[6];
for (int i = 0; i < 6; i++) {
randomnumber[i] = r.nextInt(30) + 1;
if (i > 0) {
for (int j = 0; j < i; j++) {
if (randomnumber[i] == randomnumber[j]) {
randomnumber[i] = r.nextInt(30) + 1;
}
}
}
System.out.print(randomnumber[i] + " ");
}
}
}
运行结果：
求数值型数组中最大值、最小值、平均值、总和等
求数值型数组中最大值、最小值、平均数、总和等
定义一个int型数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值并输出
public class ArrayTest02 {
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 maxValue = 0;
for(int i = 0;i<arr.length;i++) {
if(arr[i] > maxValue) {
maxValue = arr[i];
}
}
System.out.println("最大值为："+maxValue);
//求最小值
int minValue = 0;
for(int i = 0;i<arr.length;i++) {
if(arr[i] < minValue) {
minValue = arr[i];
}
}
System.out.println("最小值为："+minValue);
//和值
int sum = 0;
for(int i = 0;i<arr.length;i++) {
sum = arr[i] + sum;
}
System.out.println("和值为："+sum);
//平均值
int avgValue;
avgValue = sum/arr.length;
System.out.println("平均值为:"+avgValue);
}
}
运行结果：
数组的复制、反转、查找（线性查找、二分法查找）
使用一个简单数组
1）创建一个类，在main方法中声明arr1和arr2两个变量，他们是int[]型的数组
2）使用大括号{}，把arr1初始化为8个素数：2，3，5，7，11，13，17，19
3）显示arr1的内容
4）赋值arr2变量等于arr1,修改arr2的偶索引元素，使其等于索引[如arr[0]=0,arr[2]=2]
5)实现arr1的反转
思考：
arr1和arr2是什么关系?
答：arr1和arr2地址值都指向了堆空间的唯一的一个数组实体
拓展：修改题目：实现arr2对arr1数组的复制
public class ArrayTest02 {
public static void main(String[] args) {
int[] arr1,arr2;
arr1 = new int[] {2,3,5,7,9,11,13,17,19};
for(int i=0;i<arr1.length;i++) {
System.out.print(arr1[i]+"t");
}
System.out.println("-----------数组的复制------------");
// 不能称作是数组的复制
arr2 = arr1;
// 数组的复制
arr2 = new int[arr1.length];
for(int i=0;i < arr2.length;i++) {
arr2[i] = arr1[i];
}
for(int i=0;i<arr2.length;i++) {
if(i%2 == 0) {
arr2[i] = i;
}
System.out.print(arr2[i]+"t");
}
System.out.println("-------------数组反转-------------------------------");
// arr1的反转
String[] str= new String[]{"AA","BB","CC","DD","EE"};
for(int i=0 ; i < str.length / 2; i++) {
String temp = str[i];
str[i] = str[str.length-i-1];
str[str.length-i-1] = temp;
System.out.print(str[i]+"t");
}
// for(int i=0,j = str.length-1;i<j;i++,j--){
// String temp = str[i];
// str[i] = str[j];
// str[j] = temp;
// System.out.print(str[i]+"t");
// }
System.out.println("-------------线性查找示例------------");
// 查找(或搜索)
// 线性查找
String[] str2= new String[]{"AA","BB","CC","DD","EE"};
String dest = "BB";
boolean isFlag = true;
for(int i=0;i<str2.length;i++) {
if(dest.equals(str2[i])) {
System.out.println("找到了指定的元素，位置为："+i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.println("很遗憾，没有找到的啦！");
}
System.out.println("---------二分法查找----------");
// 前提，必须是有序的数组
int[] str3 = new int[] {1,3,4,5,7,23,33,44,55};
// 需要查找的值
int value = 3;
// 初始的头部索引
int head = 0;
// 初始的末尾索引
int end = str3.length-1;
boolean isFlagSec = true;
while(head <= end) {
int middle = (head+end)/2;
if(value == str3[middle]) {
System.out.println("找到元素了位置为："+middle);
isFlagSec = false;
break;
}else if(str3[middle] > value) {
end = middle - 1;
}else {
head = middle + 1;
}
}
if(isFlagSec) {
System.out.println("很遗憾没有找到！");
}
}
}
运行结果：
数组元素的排序算法
-
排序的概念：假设含有n个记录的序列为｛R1,R2,R3…，Rn｝，其相应的关键字序列为｛K1,K2,K3,…,Kn｝。将这些记录重新排序为｛Ri1,Ri2,Ri3,….,Rin｝ 使得相应的关键字值满足天剑Ki1<= Ki2 <= Ki3 <= …<= Kin，这样的一种操作称为排序。
-
衡量排序算法的优劣1、时间复杂度：分析关键字的比较次数和记录的移动次数 2、空闲复杂度：分析排序算法中需要多少的辅助内存 3、稳定性：若两条记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。
-
排序算法分类：
1、内部排序
指的是将需要处理的所有数据都加载到内部存储空间 中进行排序，包括（交换式排序、选择式排序和插入式排序）
2、外部排序
数据量过大，无法把所有数据加载到内存中进行排序，需要借助外部存储进行排序，包括（合并排序法和直接合并排序法）
-
十大排序算法：选择排序：直接选择排序、堆排序 交换排序：冒泡排序、快速排序 插入排序：直接插入排序、折半插入排序、Shell排序 归并排序：桶式排序: 基数排序：
-
算法五大特征：1、输入：有0个或多个输入数据，这些输入必须有清楚地描述和定义 2、输出：至少有一个或多个输出结果，不可以没有输出结果 3、有穷性（有限性）：算法在有限的步骤之后会自动结束而不会陷入无限循环，并且每一个步骤可以在可接受的时间内完成 4、确定性（明确性）：算法中每一步都是有确定的含义，不会出现二义性 5、可行性（有效性）：算法的每一步都是清楚可行的，能让用户用纸笔计算求出答案
-
冒泡排序案例：
介绍：
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依此比较相邻元素值的大小，使得值较大的元素逐渐从前向后部移动，就像水底的气泡一样逐渐向上冒。
public class BubbleSort {
public static void main(String[] args){
int[] arr = new int[]{24,69,80,57,13};
//冒泡排序
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 x =0;x<arr.length;x++){
System.out.print(arr[x]+"t");
}
}
}推导过程：
运行结果：
-
快速排序：
/**
* 快速排序
* 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
* 则分别对这两部分继续进行排序，直到整个序列序。
* @author shkstart
* 2018-12-17
*/
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：n" + java.util.Arrays.toString(data));
}
}
运行结果：
原文始发于微信公众号（Whisper Coding）：Java入门-数组使用
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/255405.html
