只有创造,才是真正的享受,只有拚搏,才是充实的生活。
本讲内容:数组
数组是Java中的对象,它用来存储多个相同类型的基本数据类型或者对象引用。
一、声明数组
数组是通过说明它将要保存的元素类型来声明的,元素类型可以是对象或者基本类型。类型后面的方括号可以在写在标识符的前面,也可以写在后面。推荐写在前面。int[ ] a int a[ ]
二、 一维数组
1、int[] a; //声明,没有初始化
2、int[] a=new int[5]; //声明并初始化为默认值,int型为0
3、 int[] a={1,2,3,4,5}; //声明并初始化为给定值
4、 int[] a; a=new int[5]; //正确,声明与初始化分开
5、int[] a; a={1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用,如3
6、 int a[];a[0]=1; a[1]=2; //错误,因为数组没有初始化,不能赋值
三、二维数组
1、 int[][] a; //声明,没有初始化
2、 int[][] a=new int[2][3]; //声明并初始化为默认值,int型为0
3、 int[][] a={{1,2},{2,3},{3,4}}; //声明并初始化为给定值
int[][] a={{1,2},{2,3},{3,4,5}}; //没有错,数组空间不是连续分配的,所以不要求每一维的大小相同
4、 int[][] a=new int[2][];
a[0]=new int[3]; //a[0]其实就是一个数组
a[1]=new int[4]; //每一维的大小可以不一样;
5、int[][] a=new int[][]{{1,2},{2,3},{3,4,5}}; //同(3)
int[] a=new int[5]{{1,2},{2,3},{3,4,5}}; //错误,如果提供了数组初始化操作,则不能定义维表达式
int[][] a=new int[2][];
a[0]={1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用
6、int[][] a=new int[2][];
a[0][1]=1; //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常
总结: 1.二维就是数组的数组,里面的数组大小不要求一样
2.不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化
四、初始化分类
1.动态初始化:数组定义与为数组分配空间和赋值的操作分开进行;
2.静态初始化:在定义数字的同时就为数组元素分配空间并赋值;
3.默认初始化:数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐士初始化。int[] a=new int[2]
下面我们通过例子讲解
1、一维数组:
<span style="font-size:18px;"><span style="font-size:18px;">public class T19 {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int arr[]=new int[5];
int sum=0;
for(int i=0;i<5;i++){
System.out.println("请输入第"+(i+1)+"学生成绩");
arr[i]=in.nextInt();
sum+=arr[i];
}
System.out.println("这5个人的平均分为"+sum/5);
}
}</span></span>
2、规则二维数组:
<span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[][] a={{1,2},{3,4},{5,6}};
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.println(a[i][j]);
}
}
}
}</span>
打印:1 2 3 4 5 6 3、不规则二维数组:
<span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[][] a={{1,2},{3,4,5},{6,7,8,9}};
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.println(a[i][j]);
}
}
}
}</span>
打印:1 2 3 4 5 6 7 8 9
4、打印图形
<span style="font-size:18px;">public class T {
public static void main(String[] args) {
int[][] arr=new int[4][6];
arr[1][2]=1;
arr[2][1]=2;
arr[2][3]=3;
//先访问行再访问列
for(int i=0;i<4;i++){//行
for(int j=0;j<6;j++){//列
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}</span>
<span style="font-size:18px;">0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0 </span>
五、数组排序
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a={7,3,6,9,4};
Arrays.sort(a);
for(int i :a){//<span style="color: rgb(51, 51, 51); font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 24px; background-color: rgb(245, 245, 245);">遍历整个集合</span>
System.out.println(i);
}
}
}</span></span>
2、冒泡法 比较相邻的俩个数,把小的数放在前面
冒泡排序是稳定性排序方法。比较适合参加排序序列的数据量较小的情况,这种方法是排序时间效率最低的一种。
总共进行 1 + 2 + 3 + 4 + . . . + n-1 = n(n-1) /2次<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a={7,3,6,9,4};
bubbleSort(a);
for(int i :a){
System.out.println(i);
}
}
public static int[] bubbleSort(int[] a){
for(int i=0;i<a.length-1;i++){//a.length=5 走几次,一次确定一个数,一共有a.length-1次
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
int temp;
temp=a[j];
a[j]=a[i];
a[i]=temp;
}
}
}
return a;
}
}</span></span>
3、选择排序算法(选择最小的一个数与第一个数交换)
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a={7,3,6,9,4};
selectSort(a);
for(int i :a){
System.out.println(i);
}
}
public static int[] selectSort(int[] a){
for(int i=0;i<a.length-1;i++){
int min=i;
for(int j=i+1;j<a.length;j++){
if(a[min]>a[j]){
min=j;
}
}
if(min!=i){
int temp=a[i];
a[i]=a[min];
a[min]=temp;
}
}
return a;
}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;">import java.util.*;
public class T {
public static void main(String[] args) {
//打印系统时间
Calendar cal=Calendar.getInstance();
System.out.println("排序前时间:"+cal.getTime());
//Math.random()让程序随机产生一个0~1
int t=(int)(Math.random()*100);
System.out.println(t);
System.out.println("排序后时间:"+cal.getTime());
}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;">排序前时间:Sat Dec 27 21:42:20 CST 2014
58
排序后时间:Sat Dec 27 21:42:20 CST 2014
</span></span>
4、插入排序法(比选择排序快)
<span style="font-size:18px;"><span style="font-size:18px;">import java.util.*;
public class T {
public static void main(String[] args) {
//打印系统时间
Calendar cal=Calendar.getInstance();
System.out.println("排序前时间:"+cal.getTime());
//Math.random()让程序随机产生一个0~1
int t=(int)(Math.random()*100);
System.out.println(t);
System.out.println("排序后时间:"+cal.getTime());
}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;">排序前时间:Sat Dec 27 21:42:20 CST 2014
58
排序后时间:Sat Dec 27 21:42:20 CST 2014
</span></span>
把n个等排序的元素看成一个有序列表和一个无序列表,开始时有序列表只有一个元素,无序列表有n-1个元素,排序过程中每次从无序列表中拿出一个数与有序列表比较,将它插入有序列表中使之成为新的有序列表。
<span style="font-size:18px;"><span style="font-size:18px;">public class T {
public static void main(String[] args) {
int len=8;
int[] arr=new int[len];
for(int i=0;i<len;i++){
int t=(int)(Math.random()*100);
arr[i]=t;
}
InsertSort is=new InsertSort();
is.sort(arr);
for(int i=0;i<len;i++){
System.out.print(arr[i]+" ");
}
}
}
class InsertSort{
public void sort(int arr[]) {
for(int i=1;i<arr.length;i++){
int insertVal=arr[i];
int index=i-1;
while(index>=0&&insertVal<arr[index]){
arr[index+1]=arr[index];
index--;
}
arr[index+1]=insertVal;
}
}
}
</span></span>
5、快速排序法(比上面的快百倍)
<span style="font-size:18px;"><span style="font-size:18px;">public class T {
public static void main(String[] args) {
int len=8;
int[] arr=new int[len];
for(int i=0;i<len;i++){
int t=(int)(Math.random()*100);
arr[i]=t;
}
InsertSort is=new InsertSort();
is.sort(arr);
for(int i=0;i<len;i++){
System.out.print(arr[i]+" ");
}
}
}
class InsertSort{
public void sort(int arr[]) {
for(int i=1;i<arr.length;i++){
int insertVal=arr[i];
int index=i-1;
while(index>=0&&insertVal<arr[index]){
arr[index+1]=arr[index];
index--;
}
arr[index+1]=insertVal;
}
}
}
</span></span>
以中间一直二分开比较
<span style="font-size:18px;">public class T {
public static void main(String[] args) {
int len=8;
int[] arr=new int[len];
for(int i=0;i<len;i++){
int t=(int)(Math.random()*100);
arr[i]=t;
}
QuickSort is=new QuickSort();
is.sort(0,arr.length-1,arr);
for(int i=0;i<len;i++){
System.out.print(arr[i]+" ");
}
}
}
class QuickSort{
public void sort(int left,int right,int[] arr) {
int l=left;
int r=right;
int pivot=arr[(left+right)/2];
int temp=0;
while(l<r){
while(arr[l]<pivot) l++;
while(arr[r]>pivot) r--;
if(l>=r) break;
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
if(arr[l]==pivot) --r;
if(arr[r]==pivot) ++l;
}
if(l==r){
l++;
r--;
}
if(left<r) sort(left,r,arr);
if(right>l) sort(l,right,arr);
}
}
</span>
六、数组Arraysr的重要方法
<span style="font-size:18px;">public class T {
public static void main(String[] args) {
int len=8;
int[] arr=new int[len];
for(int i=0;i<len;i++){
int t=(int)(Math.random()*100);
arr[i]=t;
}
QuickSort is=new QuickSort();
is.sort(0,arr.length-1,arr);
for(int i=0;i<len;i++){
System.out.print(arr[i]+" ");
}
}
}
class QuickSort{
public void sort(int left,int right,int[] arr) {
int l=left;
int r=right;
int pivot=arr[(left+right)/2];
int temp=0;
while(l<r){
while(arr[l]<pivot) l++;
while(arr[r]>pivot) r--;
if(l>=r) break;
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
if(arr[l]==pivot) --r;
if(arr[r]==pivot) ++l;
}
if(l==r){
l++;
r--;
}
if(left<r) sort(left,r,arr);
if(right>l) sort(l,right,arr);
}
}
</span>
Arrays.sort() | 排序 |
clone() | 复制数组:限制:全部复制,无法部分的复制。 |
Arrays.fill( a1, value ) | a1是一个数组变量,value是一个a1中元素数据类型的值,作用:填充a1数组中的每个元素都是value |
Arrays.fill(a, fromIndex, toIndex, val) | 第一个参数指操作的数组,第二个和第三个指在该数组的某个区域插入第四个参数,第二个参数指起始元素下标(包含该下标),第三个参数指结束下标(不包含该下标) |
Arrays.binarySearch() | 找出某个数的下标值,缺点:数组必须已经过了排序,否则结果无法预料 |
Arrays.toString() | 显示数组数据 |
例如:
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a=new int[5];
Arrays.fill(a,3);
for(int i :a){
System.out.println(i);
}
}
}</span></span>
打印:3 3 3 3 3
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a=new int[5];
Arrays.fill(a,3);
Arrays.fill(a, 1,3,1);
for(int i :a){
System.out.println(i);
}
}
} </span></span>
打印:3 1 1 3 3
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a=new int[5];
int[] b;
Arrays.fill(a, 2);
b=a.clone();
for(int i :b){
System.out.println(i);
}
}
}</span></span>
打印:2 2 2 2 2
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a = { 1, 2, 4, 5, 3 };
Arrays.sort(a);
System.out.println(Arrays.binarySearch(a, 5));
}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px;">打印:4</span></span></span>
<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
public static void main(String[] args) {
int[] a = { 1, 5, 6, 7, 3, 1 };
System.out.println(Arrays.toString(a));
}
}</span></span>
<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px; white-space: pre;">打印:</span>[1, 5, 6, 7, 3, 1]</span></span>
七、二分法查找
<span style="font-size:18px;">public class T {
public static void main(String[] args) {
int[] arr={2,3,6,89,4};
BinaryFind bf=new BinaryFind();
bf.find(0,arr.length-1,3,arr);
}
}
class BinaryFind{
public void find(int leftIndex,int rightIndex,int val,int[] arr) {
//首先找到中间的数
int midIndex=(rightIndex+leftIndex)/2;
int midVal=arr[midIndex];
if(rightIndex>=leftIndex){
if(midVal>val){
//在arr左边数中找
find(leftIndex,midIndex-1,val,arr);
}else if(midVal<val){
find(midIndex+1,rightIndex,val,arr);
}else if(midVal==val){
System.out.println("找到下标"+midIndex);
}
}
}
}</span>
<span style="font-size:18px;">找到下标1</span>
本讲就到这里,Take your time and enjoy it