数组
声明创建
dataType[] arrayRefVar; //首选
dataType arrayRefVar[];//效果相同 非首选
java语言使用new操作符来创建数组,语法如下:
dataType[] arrayRefVar = new dataType[arraySize];
package second.array;
public class Demo01 {
public static void main(String[] args) {
int[] nums;//1。声明数组
nums = new int[10];//里面可以存储10个int 数字 创建数组
//赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
System.out.println(nums[9]);
//计算所有元素和
int sum=0;
for (int i = 0; i < nums.length; i++) {
sum=sum+nums[i];
}
System.out.println("总和为:"+sum);
}
}
数组索引值从0开始 数组长度 nums.length
三种初始化:
静态初始化
int[] a={1,2,3};
Man[] mans ={new Man(),new Man()};//Man 新建类 实际是引用
动态初始化
int[] a=new int[2];
a[0]=1;
a[1]=2;
数组默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也按照实例变量同样的方法被隐式初始化
数组的四个基本特点
1.长度是确定的,数组一旦被创建,它的大小就是不可以改变的
2.其元素必须是相同类型,不允许出现混合类型
3.数组中的元素可以是任何数据类型,包括基本数据类型和引用类型
4.数组变量属引用类型,数组可以看作是对象,数组的每个元素相当于该对象的成员变量
数组本身就是对象 Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,
数组对象本身是在堆中的
小结
- 数组是相同数据类型(数据类型可以为任意类型)的有序集合
- 数组也是对象,数组元素相当于对象的成员变量
- 数组的长度是确定的,不可变的,如果越界,则报:ArrayIndexOutofBounds
数组的使用
- For-each
- 普通 for循环
- 数组作方法入参
- 数组作为返回值
package second.array;
import sun.security.mscapi.CPublicKey;
public class Demo04 {
public static void main(String[] args) {
int[] array1={1,2,3,4,5};
//增强型 for each 循环 没有下标
for (int i : array1) {
System.out.println(i);
}
printarray(array1);
int[] arrays=reversearray(array1);
printarray(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[][] array = {{1,2},{2,3},{3,4}}
package second.array;
public class Demo05 {
public static void main(String[] args) {
int[][] a= {{1,2},{2,3},{3,4},{4,5}};
System.out.println(a[0][0]);
System.out.println(a[0][1]);
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j]);
}
}
}
}
Arrays类
数组工具类· java.util.Arrays
package second.array;
import java.util.Arrays;
public class Demo06 {
public static void main(String[] args) {
int[] a= {1,25,543,55,154,15465};
//打印元素
System.out.println( Arrays.toString(a));
//排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//赋值
Arrays.fill(a,2,4,0);
System.out.println(Arrays.toString(a));
}
}
冒泡排序
代码:两次循环,外层轮数,内层依次比较
时间复杂度o(n^2)
package second.array;
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[]a={1,4,45,678,2,34,15,26,4};
int[]sort =sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[]array){
//冒泡排序
//1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
//2.每一次比较都会产生最大,或者最小的数字
//3.下一次循环可以少一次排序
//4.依次循环,直到结束
//外层循环,判断要走多少次
for (int i = 0; i < array.length - 1; i++) {
//内层循环 比较两个相邻位置的大小 如果第一个比第二个大,则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j+ 1] = temp;
}
}
}
return array;
}
}
优化
package second.array;
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[]a={1,4,45,678,2,34,15,26,4};
int[]sort =sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[]array){
//冒泡排序
//1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
//2.每一次比较都会产生最大,或者最小的数字
//3.下一次循环可以少一次排序
//4.依次循环,直到结束
boolean flag=false;
//外层循环,判断要走多少次
for (int i = 0; i < array.length - 1; i++) {
//内层循环 比较两个相邻位置的大小 如果第一个比第二个大,则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j+ 1] = temp;
flag=true;
}
}
if(flag==false){
break;
}
}
return array;
}
}
稀疏数组
当数组中大部分为0或同一数值,可以使用稀疏数组
处理方式:
- 记录数组一共几行几列 有多少各不同值
- 把具有不同元素的数组和行列及值记录在一个小规模的数组中,从而缩小程序的规模
package second.array;
import java.util.Arrays;
public class Demo08 {
public static void main(String[] args) {
//1.创建一个一维数组11*11 0:没有棋子 1.黑棋 2.白棋
int[][]array1 =new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
System.out.println("输出原始的数组:");
for(int i=0; i< array1.length;i++){
for (int j = 0; j < array1.length; j++) {
System.out.print(array1[i][j]+"\t");
}
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;
//遍历二维数组,将非零的值,存放在稀疏数组中
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++){
for (int j = 0; j < array2[i].length; j++) {
System.out.print(array2[i][j]+"\t");
}
System.out.println();
}
//还原
System.out.println("======================");
//1.读取稀疏数组
int[][] array3 =new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//3.打印
System.out.println("输出还原的数组:");
for(int i=0; i< array3.length;i++){
for (int j = 0; j < array3.length; j++) {
System.out.print(array3[i][j]+"\t");
}
System.out.println();
}
}
}
输出原始的数组:
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
======================
输出还原的数组:
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