Java数组
数组的声明
//变量的类型 变量的名字 = 变量的值
public static void main(String[] args) {
int[] nums;//声明一个数组
//使用new操作符来创建数组，语法如下
nums = new int[10];//创建一个数组
//给数组赋值
nums[0] = 1;
...........;
nums[9] = 9;
}
内存分析
java内存
- 堆
- 存放new对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈
- 存放基本的变量类型（会包含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区
数组三种初始化
静态初始化
int[] a = {1,2,3};//定义了不可改变 创建 + 赋值
Man[] mans = {new Man(1,1),new Man(2,2)};
动态初始化 包含默认初始化
int[] b = new int[10];
b[0] = 10;
数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量相同的方式被 隐式初始化（0）。
数组的四个基本特点
- 长度确定，一旦被创建，不可以改变大小
- 元素不可以是混合类型
- 可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，可以被看成是对象，每个元素相当于该对象的成员变量
- 本身就是 对象 java对象实在 堆 中 因此数组无论保存什么类型，数组对象本身是在堆中
数组的使用
-
基本用法
public class Demo { //变量的类型 变量的名字 = 变量的值 public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; //打印全部元素 for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]); } System.out.println("=================="); //计算所有元素的和 int sum = 0; for (int i = 0; i < arrays.length; i++) { sum = sum+arrays[i]; } System.out.println("sum = "+sum); System.out.println("=================="); //查找最大元素 int max = arrays[0]; for (int i = 1; i < arrays.length; i++) { if(arrays[i]>max){ max = arrays[i]; } } System.out.println("max = "+max); } } -
for — each 循环
public static void main(String[] args) { int[] arrays = {1, 2, 3, 4, 5}; //jdk 1.5 for (int array : arrays) { System.out.println(array); } } -
数组也可以作为一个参数和返回值。
//反转数组 public static int[] reverse(int[] arrays){ int[] result = new int[arrays.length]; //反转的操作 for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) { result[j] = arrays[i]; } return result; }
多维数组
//[4][2]
int[][] array = {{1,2},{2,3},{3,4}};
Arrays 类
数组工具类 Java.util.Arrays util 是工具包
- 给数组赋值：fill方法
- 给数组排序：sort方法,升序
- 比较数组：equals方法
- 查找数组元素：binarySearch方法 二分查找
public class Demo2 {
public static void main(String[] args) {
int[] a = {1,2,4,5,9,3,5,64,75,52,2};
System.out.println(a);//输出a为一个哈希code[I@1b6d3586
//打印数组元素
System.out.println(Arrays.toString(a));//输出为[1, 2, 4, 5, 9, 3, 5, 64, 75, 52, 2]
//排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));//输出为[1, 2, 2, 3, 4, 5, 5, 9, 52, 64, 75]
}
冒泡排序
冒泡排序是最出名的排序算法之一，总共有八大排序！
- 两层循环 外层冒泡论述，里层一次比较。
- 嵌套循环 时间复杂度为O(n2)
public class Demo07 {
public static void main(String[] args) {
int[] a ={1,5,8,6,54,26,54,87,56,32,12,14,5,120,132};
int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序了的数组。
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//比较数组中两个相邻的元素，并交换顺序
//每一次比较都会产生一个最大或者最小的数字
//下一轮可以少一次排序
//依次循环直到排序结束
public static int[] sort(int[] array){
int temp = 0;
//外层循环，判断我们这个要走多少步
//冒泡排序最后一个数不用排
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，交换位置
//每次循环最大的数都放在最后面 减少一次对比
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] =temp;
}
}
}
return array;
}
}
优化后
public class Demo07 {
public static void main(String[] args) {
int[] a ={1,5,8,6,54,26,54,87,56,32,12,14,5,120,132};
int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序了的数组。
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//比较数组中两个相邻的元素，并交换顺序
//每一次比较都会产生一个最大或者最小的数字
//下一轮可以少一次排序
//依次循环直到排序结束
public static int[] sort(int[] array){
int temp = 0;
//外层循环，判断我们这个要走多少步
//冒泡排序最后一个数不用排
for (int i = 0; i < array.length-1; i++) {
boolean flag = false;//通过flag标识位，减少没有意义的循环
//内层循环，比较判断两个数，如果第一个数比第二个数大，交换位置
//每次循环最大的数都放在最后面 减少一次对比
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] =temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
稀疏数组
是一种 数据结构
需求 编写 五子棋游戏 ， 有存盘 和 续上盘 的功能
- 分析问题 ：因为二维数组的很多默认值为0，因此记录了很多没有意义的意义
- 解决 ：稀疏数组 （当一个数组大部分元素是0，或者为同一个值的数组时，可以用稀疏数组来保持该数组）
- 稀疏数组处理方式：
- 记录一个数组一共有 几行和几列，有多少个不同的值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序规模。
- 稀疏数组处理方式：
左边为原始数组 右边为稀疏数组
压缩为稀疏数组
import java.awt.*;
public class Demo8 {
public static void main(String[] args) {
//创建一个二位数组，棋盘 11*11 0没有棋子 1 黑棋 2 白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输出原始数组");
for (int[] ints : array1){
for (int anInt : ints){
System.out.print(anInt+" ");
}
System.out.println();
}
//转换为稀疏数组保持
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(array1[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值的个数："+sum);
//创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
//给稀疏数组赋值
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非0的值存放到稀疏数组中
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];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < array2.length; i++) {
System.out.println( array2[i][0]+" "
+array2[i][1]+" "
+array2[i][2]+" ");
}
}
}
结果：
输出原始数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
有效值的个数：2
稀疏数组：
11 11 2
1 2 1
2 3 2
还原稀疏数组
System.out.println("====================");
System.out.println("还原数组");
//读取稀疏数组，构建新数组 行列
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//给其中的元素赋值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//打印
System.out.println("输出原始数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + " ");
}
System.out.println();
}
结果：
稀疏数组：
11 11 2
1 2 1
2 3 2
====================
还原数组
输出原始数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0