1 数组概述定义
1）数组是相同类型数据的有序集合；
2）数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成；
3）其中每一个数据成为一个数组元素，每个数组元素可以通过下标来操作。
2 数组的声明和创建
2.1数组声明
首先必须声明数组变量，才能在程序中使用数组。
//声明数组变量
dataType [] arrayRefvar;//首选方法
dataType arrayRefvar [];//效果相同，但不是首选
2.1 数组的创建
1）Java语言使用 new操作符来创建数组；
dataType [] arrayRefvar = new dataType[arraySize];
2）数组的元素是通过索引访问的，数组索引从 0开始；
3）获取数组的长度: arrayRefvar.length
2.2 数组的遍历
public class Demo06Array {
public static void main(String[] args) {
int [] nums1;//1.声明一个数组
nums1 = new int[4];//2.创建一个长度为4的数组
int [] nums2 = new int[4];
nums2[0] = 1;
nums2[1] = 2;
nums2[2] = 3;
nums2[3] = 4;
// 计算所有元素的和
int sum = 0;
for (int i = 0; i < nums2.length; i++) {
sum += nums2[i];
System.out.println("i = " + i);
}
System.out.println("sum = " + sum);
}
}
2.3 Java内存初识
1）堆：
- 存放
new的对象和数组；- 可以被所有的线程共享，不会存放别的对象引用
2）栈：
- 存放基本变量类型（包含这个基本类型的具体数值）；
- 引用对象的变量（存放的是这个引用在堆里面的具体地址）
3）方法区：
- 可以被所有线程共享；
- 包含了所有的
class和static变量
2.4 数组的三种初始化
1）静态初始化: 直接赋值
int [] a = {1,2,3};
Man [] mans = {new Man(1,1),new Man(2,2)};
2）动态初始化：
int[] a = new int[2];
a[0] =1;
a[1] =2;
3）数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public class Demo06Array {
public static void main(String[] args) {
/** 1.静态初始化：创建 + 赋值 */
int [] a = {1,2,3,4,5,6,7,8};
/** 2.动态初始化：包含默认初始化 */
int [] nums1;// 1.声明一个数组
nums1 = new int[4];// 2.创建一个数组
int [] nums2 = new int[4];
System.out.println("nums1[0]= "+ nums1[0]);
}
}
2.5 数组的四个基本特点
1）数组长度确定。数组一旦被创建，它的大小就是不可以改变的；
2）元素必须是相同类型，不允许出现混合类型；
3）数组中的元素可以是任何数据类型，包括基本类型和引用类型；
4）数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量； 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
2.6 数组的边界
1）下标的合法区间：[ 0, length-1 ],如果越界就会报错；
public static void main(String[] args) {
int [] nums1 = new int[4];
System.out.println("nums1[4]= "+ nums1[4]);
}
//java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常
2）小结：
（1）数组是
相同数据类型（数据类型可以为任意类型）的有序集合；
（2）数组也是对象。数组元素相当于对象的成员变量；
（3）数组长度是确定的，不可变的。如果越界就会报错：
java.lang.ArrayIndexOutOfBoundsException 。
3 数组的使用
3.1 普通for循环、For-Each循环
public class Demo06Array {
public static void main(String[] args) {
/** 1.静态初始化：创建 + 赋值 */
int[] a = {10,20,30,40,50,60,70,80};
int sum = 0;
/** 2.增强for循环:JDK1.5，没有下标
* 适合打印输出，不适合对元素操作*/
for (int array:a) {
System.out.print(array+"\t");
}
System.out.println("-----------");
// 3.计算所有元素的和
for (int i = 0; i < a.length; i++) {
sum += a[i];
System.out.println("i = " + i);
System.out.println("sum = " + sum);
}
System.out.println("-----------");
// 4.查找最大元素
int max = a[0];
for (int i = 1; i < a.length; i++) {
if (a[i] > max){
max = a[i];
}
}
System.out.println("max= " + max);
}
}
3.2 数组做方法入参
public class Demo07ArrayPro {
public static void main(String[] args) {
int[] arrays = {10,20,30,40,50,60,70,80};
printArray(arrays);
}
/** 打印数组元素 */
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+ "\t");
}
}
}
3.3 数组做返回值
将数组元素反转后输出。
方法一：创建一个新数组，将元素进行重新赋值后输出
public class Demo07ArrayPro {
public static void main(String[] args) {
int[] arrays = {10,20,30,40,50,60,70,80};
int[] ints = reverse(arrays);
printArray(ints);
}
/** 反转数组 */
public static int[] reverse(int[] arrays){
int[] reArrays = new int[arrays.length];
/** 反转操作,方法一
for (int i = 0; i < arrays.length; i++) {
reArrays[arrays.length-(i+1)] = arrays[i];
}*/
// 反转操作,方法二
for (int i = 0, j= reArrays.length-1;
i < arrays.length; i++, j--) {
reArrays[j] = arrays[i];
}
return reArrays;
}
/** 打印数组元素 */
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+ "\t");
}
}
}
方法二：当该数组是数据数组时直接对元素操作，将操作后的元素进行重新赋值后输出
public class Demo07ArrayPro {
public static void main(String[] args) {
int[] arrays = {10,20,30,40,50,60,70,80};
int[] ints = reverse(arrays);
printArray(ints);
}
/** 反转数组方法三:对一个数组直接进行操作，不需要另外新建一个数组 */
public static int[] reverse(int[] arrays){
for (int i = 0 ; i < arrays.length; i++) {
arrays[arrays.length-(i+1)] = arrays[arrays.length-(i+1)] - arrays[i];
arrays[i] = arrays[arrays.length-(i+1)] + arrays[i]
arrays[arrays.length-(i+1)] = arrays[i] - arrays[arrays.length-(i+1)];
}
return arrays;
}
// 打印数组元素
public static void printArray(int[] arrays){
for (int array : arrays) {
System.out.print(array[i] + "\t");
}
}
}
4 多维数组
1）多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个二维数组；
2）二维数组的创建
//可以看成是一个 2行3列的数组
int a[][] = new int[2][3];
3）多维数组的遍历（这里以二维数组为例）
public class Demo08ArrayPP {
public static void main(String[] args) {
/** [2][3]:2行3列
* 10 11 12 array[0]
* 20 21 22 array[1]
*/
int[][] array= {{10,11,12},{20,21,22}};
System.out.println(array[0][0]);//10
System.out.println(array.length);//2行
System.out.println(array[0].length);//3列
//遍历二维数组
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
}
5 Arrays类
1）数组的工具类：java.util.Arrays;
2）由于数组对象本身并没有什么地方可以供我们调用，但 API中提供了一个工具类 Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
3）查看 JDK帮助文档；
4）Arrays类中的方法都是 static修饰的静态方法，在使用的时候可以直接使用类名直接进行调用，而“不用”使用对象来调用（注意是“不用” 而不是“不能”）；
5）Arrays类具有以下常用功能：
（1）给数组赋值：fill()方法；
（2）对数组排序：sort()方法，按值升序；
（3）比较数组：equals()方法，比较数组中元素值是否相等；
（4）binarySearch()方法能对排序好的数组进行二分查找
6 八大排序之冒泡排序
1）冒泡排序无疑是最为出名的排序算法之一！
2）冒泡的代码是相当简单的，两层循环，外层冒泡轮数，里层依次比较；
3）看到嵌套循环想到时间复杂度为O(n²)。
4）排序过程特点：
（1）比较数组中两个相邻元素，如果 [x]>[x+1] ，它们交换位置；
（2）每一次比较都会产生一个最大或最小的数字；
（3）下一轮就可以少一次排序；
（4）依次循环，直到结束。
5）冒泡排序代码演示：
package com.method;
import java.util.Arrays;
public class Demo10BubbleSort {
public static void main(String[] args) {
int[] a = {8,5,7,1,4,19,217,11,14,9,2};
bubbSort(a);
System.out.println(Arrays.toString(a));
}
public static int[] bubbSort(int[] array){
//临时变量
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
// 通过flag标志位减少没有意义的比较
boolean flag = false;
for (int j = 0; j < array.length -1- i; j++) {
if (array[j+1] < array[j]){
temp = array[j] - array[j+1];
array[j+1] = array[j+1] + temp;
array[j] = array[j] - temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
7 稀疏数组
稀疏数组就是一种压缩算法。
1）当一个数组中有大量元素为0 或者为同一值的数组时，可以使用稀疏数组来保存该数组；
2）稀疏数组的处理方式：
（1）记录数组一共几行几列，有多少个不同值；
（2）把具有不同值的元素和行列及值记录在一个小规模的数组中，从而压缩程序的规模；
3）如下图，左边是原始数组，右边是稀疏数组
4）稀疏数组代码示例
public class Demo11SparseArray {
public static void main(String[] args) {
/** 1.创建一个 9*9二维数组
0：没有棋子;1：白棋；2：黑棋*/
int[][] array1 =new int[9][9];
array1[3][2]= 1;
array1[2][5]= 2;
/** 2.输出原始数组 */
System.out.println("原始数组:");
for (int[] ints: array1) {
for (int anInt: ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
/** 3.转换为稀疏数组*/
/* 3.1.遍历数组，获取有效值的个数*/
int sum= 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
sum++;
}
}
}
/* 3.2.创建一个稀疏数组的数组*/
int[][] array2= new int[sum+1][3];
array2[0][0]= 9;
array2[0][1]= 9;
array2[0][2]= sum;
/* 3.3.遍历原始数组，将非零的值存放在稀疏数组中*/
int count= 0;// 行
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++;
array2[count][0]= i;
array2[count][1]= j;
array2[count][2]= array1[i][j];
}
}
}
/* 3.4.输出稀疏数组*/
for (int i = 0; i < array2.length; i++) {
System.out.println("稀疏数组 "+
array2[i][0]+ "\t"+
array2[i][1]+ "\t"+
array2[i][2]+ "\t");
}
}
}
还原稀疏数组：
/**4.稀疏数组的还原*/
/*4.1 读取稀疏数组*/
int[][] array3= new int[array2[0][0]][array2[0][1]];
/*4.2 给其中的元素赋值*/
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]]= array2[i][2];
}
/**2.输出数组 */
System.out.println("数组:");
for (int[] ints: array3) {
for (int anInt: ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
1472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
