java中的数组

2.1 Java中的数组

2.1.1 数组

【装元素的容器】：装类型相同，存储空间连续的元素

int[] data = new int[空间大小];
int[] data = new int[]{元素,元素,元素…};
int[] data = {元素,元素,元素…};

得到某一个元素：
System.out.println(data[下标]);

得到数组的大小：

System.out.println(data.length);

如何遍历数组对象：

for + 下标
for(int x = 0;x < data.length;x++){
System.out.println(data[x]);
}

foreach
for(数据类型 x : 数组对象){
System.out.println(x);
}

public class Exec1{
public static void main(String[] args){
char[] r={'e','t','o','a','k'};
System.out.println(r[0]);
System.out.println(r.length);
for(int i=0;i<r.length;i++){//这里面的int x是从r数组里面下标
System.out.print(r[i]);//遍历输出
}
}}

//升级版for循环-》foreach （since from jdk5.0）
char[] r={'e','t','o','a','k'};
for(char x:r){//这里面的 char x是从r数组里面取出来的元素
System.out.println(x);//遍历输出
}

例子：拉灯：100个人分别进入100个房间，房间号可以整除人编号要拉一下灯，求第100个人拉完之后哪些灯亮着

//以人为出发点，1人分别去能被自己整除的房间拉一下灯
public class TurnOnLight{
	public static void main(String[] args){
	   boolean [] light=new boolean [100];
	   for(int i=1;i<=100;i++){//人
			for(int j=i;j<=100;j+=i){//房间号（直接走倍数，不用判断）
				//if(j%i==0){
					light[j-1]= !light[j-1];
				//}
				}
			}
			for(int a=0;a<light.length;a++){
				if(light[a]){
						System.out.println(a+1);	}	}
}}

//以房间为出发点，房间被进入奇数次灯是亮着的
public class TurnOnLight2{
	public static void main(String[] args){
	   boolean [] light=new boolean [100];
	   for(int i=1;i<=100;i++){//房间
	       int count=0;
			for(int j=1;j<=100;j++){//人编号
		   		if(i%j==0){
					count++;
			}
				}
			if(count%2==1){
				System.out.print(i+" ");	}
			}
}}

结果如图：

数组的复制：(先创建新数组)System.arraycopy(老数组对象,老数组的起始下标,目标数组,目标的下标,复制的长度)

​ 新数组对象 x =Arrays.copyOf(老数组对象,新数组的长度) 需要import java.util.*;

int[] data1={1,2,3};
int[] data2=new int[data1.length+1];
data2[3]=66;
System.arraycopy(data1,0,data2,0,3);
for(int x:data2){
System.out.print("新的"+x+" "); }

import java.util.*;
public class ArrayTest{
public static void main(String[] args){
int[] data={45,66,80,27,19,88};//不要复制27
//int[] temp=Arrays.copyOf(data,data.length-1);
//int[]  temp= new int[data.length-1];
System.arraycopy(data,4,data,3,2);
int[] temp=Arrays.copyOf(data,data.length-1);
for(int x:temp){
	System.out.println(x);
	}
}}

import java.util.*;
public class ArrayTest{
public static void main(String[] args){
int[] data={45,66,80,27,19,88};//不要复制27
System.arraycopy(data,4,data,3,2);
int[] temp=Arrays.copyOf(data,data.length-1);
for(int x:temp){
	System.out.println(x);
	}
}}

应用场景：

1）对数组进行不可逆操作，备份数组

2）数组太大/太小，创建新的数组，将老的数组重新添加进来

2.1.2 数组的排序

手动排序：冒泡排序

public class Maopao{
	public static void main(String[] args){
		int[] data = {20,12,45,43,32,17,97,87,56,34};
		for(int j=0;j<data.length-1;j++){//j为比较次数，i为下标
			for(int i=0;i<data.length-1-j;i++){//比较一次就可以将最大值取出，即可以少比较一次（效率更高）
						if(data[i]>data[i+1]){//升序排列
							data[i]=data[i] ^data[i+1];
							data[i+1]=data[i] ^data[i+1];
							data[i]=data[i] ^data[i+1];
							}
		       	}
			}
			for(int x:data){
				System.out.println(x);
			}
    }
}

public class ExecChar{
	public static void main(String[] args){
		char[] data = {'C','a','d','A','b','D','c','B'};
				//排序：A   a   B    b   C    c   D   d
		//ascii 65  97  66   98  67   99  68  100
		double [] asc = new double[data.length];
		for(int x = 0;x < data.length;x++){
			asc[x] = data[x] >=97 ? (data[x]-31.5): data[x];
	}
		for(int i=0;i<asc.length-1;i++){
			for(int j=0;j<asc.length-1-i;j++){
				if(asc[j]>asc[j+1]){
					double z =asc[j];
					asc[j]=asc[j+1];
					asc[j+1]=z;

					data[j] =(char)(data[j] ^ data[j+1]);
					data[j+1] =(char)(data[j] ^ data[j+1]);
					data[j] =(char)(data[j] ^ data[j+1]);
					}
}
			}
			for(char x:data){
				System.out.println(x);}
}
}