第五章总结。

1:一维数组

一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一些数据时，可以应用这种类型的数组。

创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

一维数

先声明，在用new关键字进行内存分配组的创建有两种方式

数组元素类型  数组名字[ ];

 数组元素类型  [ ] 数组名字;

数组元素类型决定了数组的数据类型，它可以是Java中任意的数据类型，声明数组后我们还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用它还要为它分配内存空间，在位数组分配内存空间时必须指明数组的长度，格式如下：

数组名字=new 数组元素的类型[数组元素的个数]

2.声明的同时为数组分配内存
数组元素的类型 数组名=new 数组元素的类型[数组元素的个数]；

 初始化数组

int arr[ ]=new int [ ]{1,2,3,5,25};

int arr[ ]={34,23,12,6};

数组元素赋值        

        数组名[索引]=值；
例题

package a;
public class A {
 
	public static void main(String[] args) {
 
		int d[]=new int [] {//创建并初始化一维数组
				31,28,31,30,31,30,31,31,30,31,30,31
		};
		for(int i=0;i<12;i++) {//利用循环输出信息
			System.out.println((i+1)+"月有"+d[i]+"天");//输出每月天数
		}
		
		
		
	}
}
 

如果将12改成11，那么只会输出11个月，但是将12改成13，会输出12个月然后报错 

这个错误是数组越界，是比较常见的错误

我们为此有两种解决办法

1.将i<某数，改为     数组名.length,这是数组长度的意思，这样就不会出错

2.使用foreach循环

 例题2

ublic class Learn009 {
 
    public static void main(String[] args) {
        int []arr=new int [] {
                5,13,96
        };
        //for循环遍历数组
        for(int i=0;i<arr.length;i++) {
            int temp =arr[i];
            System.out.println(temp);
            
        }
        //foreach循环遍历数组
        for (int temp:arr) {
            System.out.println(temp);
            
        }
 
    }
 

 二维数组

 数组元素类型  数组名字[ ] [ ] ;

数组元素类型  [ ]  [ ] 数组名字;

 分配内存

数组名 =new 数组元素的类型[ 行数] [列数];

 数组元素赋值        

      数组名[行号] [列号]=值； 

例题 

public class Learn009 {
 
    public static void main(String[] args) {
        int a[][]=new int[3][4];//定义一个3行4列的二维数组
        for(int i=0;i<a.length;i++) {//遍历数组
            for(int j=0;j<a[i].length;j++) {//.length是数组长度
                System.out.print(a[i][j]);//输出
            }System.out.println();
        }
 
    }
 
}

运行结果

 

填充替换数组

使用Arrays这个类，具体格式为

Arrays.fill(数组名，替换的值）；

package 例题;
import java.util.Arrays;//导入类
 
public class h {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]=new int [5];//创建数组
        Arrays.fill(arr, 8);使用同一个值填充数组
        for (int i=0;i<arr.length;i++) {//遍历数组
            System.out.println("第"+i+"个元素是"+arr[i]);
        }
    }
 
}

 

复制数组元素（空位补0，溢出去掉） 

新数组名=Arrays.copyOf（旧数组名，新数组长度）；

import java.util.Arrays;
 
public class Learn009 {
 
    public static void main(String[] args) {
        int arr[]=new int [] {23,42,12};//定义数组
        int newarr[]=    Arrays.copyOf(arr,5);//复制数组到新数组中
            for (int i=0;i<newarr.length;i++) {//遍历数组
                System.out.println(newarr[i]);
                
        }
    }

 

复制数组部分元素（前在后不在）

新数组名=Arrays.copyOfRange（旧数组名，前索引，后索引）；

 

package 例题;
import java.util.Arrays;//定义类
 
public class h {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]=new int [] {23,42,12,84,10};//定义数组
	int newarr[]=	Arrays.copyOfRange(arr,1,4);//复制数组到新数组
		for (int i=0;i<newarr.length;i++) {//遍历数组
			System.out.println(newarr[i]);
		}
	}
 
}

 

数组元素排序

Arrays.sort(数组名)；

查询数组元素（先排序再查询）

索引=Arrays.binarySearch(数组名，元素)；

 

import java.util.Arrays;
 
public class 例题1 {
 
    public static void main(String[] args) {
        int arr[]=new int [] {1,8,9,4,5};//定义数组
        Arrays.sort(arr);//对数组进行排序
        int i=Arrays.binarySearch(arr, 4);//找到数组中元素4的值
            
                System.out.println("4的索引位置是"+i);//输出
 
    }

—

运行结果：

 

查询部分元素 （先排序再查询，前含后不含）

索引=Arrays.binarySearch(数组名，前索引，后索引，元素)；

import java.util.Arrays;
 
public class 例题2 {
 
    public static void main(String[] args) {
        String arr[]=new String []{"ab","cd","ef","yz"};//定义string型数组
        Arrays.sort(arr);//排序
        int i=Arrays.binarySearch(arr,1,3,"cd");//在指定范围内搜索元素cd的索引位置
            
                System.out.println("cd的索引位置是："+i);//输出
 
    }
}

运行结果

 

 

排序

冒泡排序

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数

例题4：

import java.util.Arrays;
 
public class 例题3 {
 
    public static void main(String[] args) {
        int []arr= {63,4,24,1,3,15};//定义数组
        Learn009 soter=new Learn009();//创建冒泡排序的对象
        soter.sort(arr);//调用排序方法
        }
        public void sort(int[]arr) {//创建一个
            for (int i=1;i<arr.length ;i++) {//比较两个数，大的往后
                for (int j=0;j<arr.length-i;j++) {
                    if(arr[j]>arr[j+1]) {//交换数
                        int temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
            showArray(arr);//输出
        }
        public void showArray(int[]arr) {
            for(int i:arr) {
                System.out.print(">"+i);
                
            }System.out.println();
 
    }

运行结果：

直接排序

将最大的数放到最后，固定不动，第二次再将最大的数放到最后，固定不动，往后继续。

例题5：

import java.util.Arrays;
 
public class 例题5 {
 
    public static void main(String[] args) {
        int []a= {64,4,24,1,3,15};//定义数组
        int d;//最大值
        for(int i=1;i<a.length ;i++) {//外循环，要轮几次
            d=0;//初始化
            for(int j=1;j<a.length-i;j++) {//比大小
                if(a[j]>a[d]) {//最大值转换
                    d=j;
                }
            }
            int t=a[a.length-i];//将索引赋给临时变量t
            a[a.length-i]=a[d];//将最大值放到已经空掉的索引内，达到交换的目的
            a[d]=t;//将之前索引的值赋给临时变量
        }
        for(int i:a) {//遍历数组
            System.out.print(">"+i);
        }
 
    }

 

运行结果：

反转排序

就是第一个数和最后一个数交换，第二个数和倒数第二个数交换，第三个数和倒数第三个数交换，以此类推。就像一面镜子，如果是单数中间那个不会交换。