Java基础04:数组
-
数组概述
-
数组声明创建
-
数组使用
-
多维数组
-
Arrays类
-
稀疏数组
数组定义
-
数组是相同类型的数据有序集合
-
数组描述的是相同类型若干个数据，按照一定先后次序排列组合而成
-
其中，每一个数据称作一耳个光数组元素，每个元素可以通过一个下标来访问
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组
dataType[] arrayRefvar;//首选方法
或者
dataType arrayRefvar[];
-
java语音使用new操作符来创建数组
dataType[] arrayRefvar = new dataType[arraySize];
-
数组的元素是通过索引访问的，数组索引从0开始
-
获取数组长度：arrays.length
public class ArrayDemo01 {
public static void main(String[] args) {
int[] numbs;//1、声明一个数组
numbs = new int[10];//2、创建一个数组 10是数组大小
numbs[0]=1;//3、给数组元素赋值
numbs[1]=2;
numbs[2]=3;
numbs[3]=4;
numbs[4]=5;
numbs[5]=6;
numbs[6]=7;
numbs[7]=8;
numbs[8]=9;
numbs[9]=10;
//计算所有元素的和
int sum = 0;
//numbs.length获取数组长度
for (int i = 0; i <numbs.length ; i++) {
sum=sum+numbs[i];
}
System.out.println("总和为："+sum);
}
}
内存分析
-
堆
-
存放new的对象和数组
-
可以被所有线程共享，不会存放别的对象引用
-
-
栈
-
存放基本变量类型（会包含这个基本类型的具体数值）
-
引用对象的变量（会存放这个引用在堆里面的具体地址）
-
-
方法区
-
可以被所有的线程共享
-
包含了所有的class和static变量
-
数组三种初始化
-
静态初始化
int[]a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};
-
动态初始化
int[] a =new int[2];
a[0]=1;
a[1]=2;
-
数组默认初始化
-
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化
-
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化：创建+赋值
int[] a ={1,2,3};
System.out.println(a[0]);
//动态初始化:包含默认初始化
int[] b=new int[10];
b[0]=1;//赋值
System.out.println(b[0]);
System.out.println(b[1]);//未赋值，初始化时默认初始化为0，当为String类型时，默认是null
System.out.println(b[2]);
}
}
数组的四个特点
-
数组长度确定的。数组一旦创建，大小就不可以改变
-
其元素必须是同类型，不允许出现混合类型
-
数组中的元素可以是任何数据类型，包含基本类型和引用类型
-
数组变量数引用类型，数组也可看做对象，数组中的每个元素相当于对象的成员变量
-
数组本身就是对象，java的对象是存在的堆中的，因此苏州无论保存原始类型或者其他对象类型，数组对象本身都存在堆中
数组边界
-
下标的合法区间；[0,length-1],如果越界就会报错
pbulic static void main(String[] args){
int[] a=new int[2];
System.out.println(a[2])//报错ArrayIndexOutBoodsException
}
-
ArrayIndexOutBoodsException:数组下标越界
-
小结：
-
数组是相同数据类型（数据类型可以为任意类型）的有序集合
-
数组也是对象。数组元素相当于对象的成员变量
-
数组长度是确定的，不可变，如果越界就会报错
-
数组使用
-
For-Each循环
public class ArrayDemo05 {
public static void main(String[] args) {
//输出数组中每个元素
int[] arrays={1,2,3,4,5};
for (int array:arrays){
System.out.println(array);
}
}
}
-
数组作方法入参
-
数组作返回值
public class ArrayDemo05 {
public static void main(String[] args) {
//输出数组中每个元素
int[] arrays={1,2,3,4,5};
for (int array:arrays){
System.out.println(array);
}
System.out.println("-------------------");
printArray(arrays);
System.out.println("-------------------");
printArray(reverseArray(arrays));
}
public static void printArray(int[] array){
//输出数组中的元素
for (int i = 0; i <array.length ; i++) {
System.out.println(array[i]+" ");
}
}
public static int[] reverseArray(int[] array){
//将数组中的元素逆序排列
int[] result = new int[array.length];
for (int i = 0,j=array.length-1; i < array.length; i++,j--) {
result[j]=array[i];
}
return result;
}
}
多维数组
-
多维数组可以看成是数组的数组，比如二位数组就是一个特殊的数组，其中每一个元素就是一个一维数组
-
二维数组
int a[][]=new int[2][5];
-
解析：以上二维数组a可以看成一个2行5列的数组
public class ArrayDemo06 {
public static void main(String[] args) {
/* [1,2]
2,3
3,4
4,5
*/
int[][] array ={{1,2},{2,3},{3,4},{4,5}};
// printArray(array[0]);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j <array[i].length ; j++) {
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
public static void printArray(int[] array){
//输出数组中的元素
for (int i = 0; i <array.length ; i++) {
System.out.println(array[i]+" ");
}
}
}
-
思考：多维数组的使用？
Arrays类
-
数组的工具类：java.util.Arrays
-
由于数组对象本身没有什么方法可以调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作
-
查看JDK帮助文档
-
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”，而不是“不能”）
-
具有一下常用功能：
-
给数组赋值：通过 fill方法
-
对数组排序：通过sort方法
-
比较数组：通过 equals方法比较数组中元素是否相等
-
查询数组元素：通过binarySearch方法能对已排序好的数组进行二分查找法操作
public class ArrayDemo07 {
public static void main(String[] args) {
int[]a={1,2,4,55,44,75,4234324,33,1};
System.out.println(a);//[I@4554617c 输出的是对象
System.out.println(Arrays.toString(a));
//将数组元素转化为String [1, 2, 4, 55, 44, 75, 4234324, 33, 1]
Arrays.sort(a);//数组进行排序：升序
// [1, 1, 2, 4, 33, 44, 55, 75, 4234324]
System.out.println(Arrays.toString(a));
Arrays.fill(a,0);//用0将数组a填充
// [0, 0, 0, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.toString(a));
}
}
-
冒泡排序
-
冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
-
冒泡排序代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较
-
看到嵌套循环，应该立马可以得出算法的时间复杂度O(n2)
-
思考：如何优化？
public class ArrayDemo08 {
public static void main(String[] args) {
int[] a={1,3,2,4,555,62,1,3,3,44,5,5,5};
System.out.println(Arrays.toString(sort(a)));
}
//冒泡排序
/*
1、比较数组中，俩个相邻的元素，如果第一个比第二个数大，我们交换位置
2、每次比较，都会产生一个最大或者最小的数字
3、下一轮则可以少一次排序
4、依次循环，直到结束
*/
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-i-1;j++){
if(array[j+1]<array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
public static int[] sortNew(int[] array){
int temp= 0;
for (int i = 0; i <array.length-1 ; i++) {
boolean flag=false;
for(int j=0;j<array.length-i-1;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，或者同一值的数组时，可以使用稀疏数组来保存改数组
-
稀疏数组处理方式：
-
记录数组一共几行几列，有多个不同的值
-
把具有相同的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模
-
-
作用：压缩存储空间，节约资源
public class ArrayDemo09 {
public static void main(String[] args) {
//1.创建一个二维数组 11*11 0么有棋子 1：黑棋 2：白棋
/* 1
输出原始的数组：
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
*/
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+"\t");
}
System.out.println();
}
System.out.println("-------------------");
//转换为稀疏数组
//1、获取有效值个数
int sum=0;
for (int i = 0; i <11 ; i++) {
for(int j=0;j<11;j++){
if(array1[