Java数组

一维数组的创建以及应用

声明一维数组有两种方式:
数组元素类型 数组名字[ ];
数组元素类型[ ] 数组名字;

int arr[]; //声明int型数组,数组中每个元素都是int型数值
String str[];//声明String数组,数组中每个元素都是String型数值
这样还不能立即去访问它额任何元素,因为声明数组只是给出了数组的名字和元素的数据类型,要使用数组,还需要分配的它的空间,
数组名字=new 数组元素类型[数组元素的个数];
arr=new int[5];
数组名字:被连接到数组变量的名称
数组元素个数:指定数组中变量的个数,就是数组的长度.
声明数组的同时也可以分配内存;
int month[]=new int[12]
初始化以为数组
int arr[]=new int[]{1,2,3,5,25};//第一种初始化方式
int arr2[]={12,23,34,1}//第二种初始化方式
使用一维数组输出1~12月的天数

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

二维数组的创建与应用
声明二维数组的语法:
数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;

int arr[][] ;
跟一维数组一样,二维数组在声明的同时也没有分配内存空间,也需要用new关键字来分配内存,然后才能反问每个元素.
对于高维数组,也有两种分配方式:
1.)直接为每一维分配内存空间
arr=new int [2][4];
2.)分别为每一维分配内存
arr=new int [2][];
arr[0]=new int [2];
arr[1]=new int[3];
可以在声明同时为数组分配内存
type arrayname[][]={value1,value2,value3…value};
type:数组数据类型
arrayname:数组名称,一个合法的标识符
value:数组中各元素的值
初始化二维数组
int arr[][]={{12,3},{13,5}};
初始化二维数组后,要明确数组的下标都是从0开始.
比如: arr[11]=20
使用二维数组输出一个4行4列且所有元素都是0的矩阵

public class Matrix {
    public static void main(String[] args){
        int arr[][]=new int[4][4]; //定义二维数组
        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr[i].length;j++){ //循环遍历数组中的每个元素
                System.out.print(arr[i][j]);//输出
            }
            System.out.println();
        }
    }
}

数组的基本操作
1.遍历数组
遍历数组就是获取数组中的每个元素.通常遍历数组都是用for循环来实现的.
遍历二维数组,获取数组的长度

public class Traverse {
    public static void main(String []args){
        int arr[][]=new int[][]{{1},{2,3},{4,5,6}};//定义二维数组
        for (int k=0;k<arr.length;k++){
            for (int c=0;c<arr[k].length;c++){//循环遍历二维数组中的每个元素
                System.out.print(arr[k][c]);//输出
            }
            System.out.println();
        }
    }
}

使用foreach遍历

public class Ergodic {
    public static void main(String []args){
        int arr[][]={{4,3},{5,6}};//定义二维数组
        System.out.println("数组中的元素是:");//提示信息
        for (int x[]:arr){ //外层循环变量为一维数组
            for (int e:x){//循环遍历没一个元素
                if (e==x.length){//判断变量是否为二维数组中的最后一个 元素
                    System.out.print(e);//输出二维数组的最后一个元素
                }else //如果不是二维数组中的最后一个元素
                    System.out.print(e+"、");
            }
        }
    }
}

填充替换元素
通过Arrays类的静态方法fill()可以来对数组的元素进行替换;
1.)fill(int[]a,int value)
该方法可以将指定的int值分配给int型数组的每个元素.
a:要进行元素替换的数组
value:要存储数组中所有元素的值

import java.util.Arrays;//导包
public class Substitute {
    public static void main(String[]args){
        int arr[]=new int[5];
        Arrays.fill(arr,8);//使用一个值对数组进行替换
        for (int i=0;i<arr.length;i++){//遍历循环数组中的元素
            System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素一次输出
        }
    }
}

fill(int[]a,int fromIndex,int toIndex,int value)
a:要进行填充的数组
fromIndex:要使用指定值填充的第一个元素索引(包括)
toIndex:要使用指定值填充一个元素的作引(不包括)
value:要存储在数组所有元素中的值

import java.util.Arrays;//导包
public class Replace {
    public static void main(String []args){
        int arr[]=new int[]{45,12,2,10};//定义并初始化int型数组arr
        Arrays.fill(arr,1,2,8);//使用fill()方法对数组进行初始化
        for (int i=0;i<arr.length;i++){//循环遍历数组中的元素
            //将数组中的每个元素输出
            System.out.println("第"+i+"个元素是:"+arr[i]);
        }
    }
}

数组排序
通过Arrays类的静态sort()方法可以实现对数组的排序,sort()方法提供了多种重载型系,可对任意类型的数组进行升序排序.
Arrays.sort(object)
从小到大排列

import java.util.Arrays;
public class Arrange {
    public static void main(String []args){
        int arr[]=new int[]{23,34,32,24};
        Arrays.sort(arr);//排列
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);//输出
        }
    }
}

复制数组
Arrays类的copy()方法与copyOfRange()方法可以实现对数组的复制.其中copyOf()方法是复制至指定长度,copyOfRange()方法则将指定数组的指定长度复制到一个新数组中.
copyOf()方法
该方法提供了多种重载形式,用于满足不同类型数组的复制
copyOf(arr,int newlength)
arr:要进行复制的数组
newlength: int 型常量,指复制后的新数组的长度.如果新数组的长度大于数组arr的长度,则用0填充;如果复制后的数组长度小于数组arr的长度,则会从数组arr的第一个元素开始截取至满足新数组长度为止.

import java.util.Arrays;
public class Copy {
    public static void main(String []args){
        int arr[]=new int[]{12,23,34};//定义数组
        int newarr[]= Arrays.copyOf(arr,5);//复制数组arr
        for (int i=0;i<newarr.length;i++){//循环变量复制后的数组
            System.out.println(newarr[i]);//输出新的数组
        }
    }
}

copyOfRange()方法
该方法同样提供了多中重载形式
copyOfRange(arr,int formIndex,int toIndex)
arr:要进行复制的数组
formIndex:指定开始复制数组的索引位置,formIndex必须在0至整个数组的长度之间,新数组包括索引是formIndex的元素.
toIndex:要复制范围的最后索引位置,可以大于数组arr的长度,新数组不包括索引是toIndex的元素.

import java.util.Arrays;
public class Replication {
    public static void main(String args[]){
        int arr[]=new int[]{12,23,34,45,56};
        int newarr[]= Arrays.copyOfRange(arr,0,3);//复制数组
        for (int i=0;i<newarr.length;i++){//循环遍历
            System.out.println(newarr[i]);//输出
        }
    }
}

数组查询
Arrays类的binarySearch()方法,可以使用二分法来搜索指定数组,以获得指定对象.该方法返回搜索元素的索引值,binarySearch()方法提供了多种重载形式,用于满足各种类型数据的查找需要,binarySearch()方法有两种参数类型.
binarySearch(Object[].Object key)
a:要搜索的数组
key:要搜索的值

import java.util.Arrays;
public class Query {
    public static void main(String[]args){
        int arr[]=new int[]{1,3,9,5,8,7};
        Arrays.sort(arr);//将数组进行排序
        int index=Arrays.binarySearch(arr,5);//查找数组中的4的索引位置
        System.out.println("4的索引位置是:"+index);
    }
}

binarySearch(Object[].,int fromIndex,int toIndex,Object key )
a:要进行检索的数组
fromIndex:指定范围的开始处索引(包含)
toIndex:指定范围的结束处索引(不包含)
key:要搜索的元素
注意
如果指定的范围大雨或等于数组的长度,则会报出ArrayIndexOutOfBoundsExcepyion异常.

import java.util.Arrays;
public class Demand {
    public static void main(String []args){
        //定义String型数据str

        String str[]=new String[]{"ab","cd","ef","gh"};
        Arrays.sort(str);
        //在指定范围内搜索元素"cd"的索引位置
        int index=Arrays.binarySearch(str,0,2,"cd");
        System.out.println("cd的索引位置是:"+index);
    }
}

数组排序算法
1.冒泡排序
基本思想:冒泡排序的基本思想是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组前面,把大的元素移动到数组后面,这样较小的元素就想气泡一样从底部上升到顶部.

public class BubbleSort {
    public static void main(String []args){
        int[]array={23,45,1,4,3,6,67};
        BubbleSort sorter=new BubbleSort();
        sorter.sort(array);
    }
/**
 * 冒泡排序
 * @param  array
 * 要排列的数组
 *
 * */
    public void sort(int[] array) {
        for (int i=1;i<array.length;i++){
            //比较相邻两个元素,较大的数往后冒泡
            for (int j=0;j<array.length-i;j++){
                if (array[j]>array[j+1]){
                    int temp=array[j];//把第一个元素保存到临时变量中
                    array[j]=array[j+1];//把第二个元素保存到第一个中
                    array[j+1]=temp;//把临时变量保存到第二个元素中

                }
            }
        }
        showArray(array);//输出冒泡排序后的数组元素
    }

    /**
     * 显示数组中的所有元素
     *
     * @param array
     * 要显示的数组
     *
     * */
    public void showArray(int[]array){
        for (int i:array){  //遍历数组
            System.out.print(">"+i);//输出每个数组的元素值
        }
        System.out.println();
    }
}

2.直接选择排序
直接选择排序方法属于选择排序的一种,它的排血速度要比冒泡排序快一些,也是常用的排序算法.
基本思想:直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比,如果满足条件就换元素值,这里不是相邻交换元素,而是把满足条件的元素与指定的排序位置交换.

/**
 * 直接选择排序
 *
 */
public class SelectionSort {
    public static void main(String []args){
        //创建一个元素乱序的数组
        int[]array={43,56,23,12,3,50,7,91};
        //创建直接排序类的对象
        SelectionSort sorter=new SelectionSort();
        //调用排序对象的方法将数组排序
        sorter.sort(array);
    }
    /**
     * @param array
     * 要排列的数组
     * */
    public void sort(int[] array) {
        int index;
        for (int i=1;i<=array.length;i++){
            index=0;
            for (int j=1;j<=array.length-i;j++){
                if (array[j]>array[index]){
                    index=j;
                }
            }
            //交换位置array.lenghth-i和index上的两个数
            int temp=array[array.length-i];//把第一个元素保存到临时变量中
            array[array.length-i]=array[index];//把第二个元素保存到第一元素单元中
            array[index]=temp;//把临时变量也就是第一个元素原值保存到第二个元素中
        }
        showArray(array);//输出直接选择排序后的数组值
    }

    public void showArray(int[] array) {
        for (int i:array){
            System.out.print(">"+i);
        }
        System.out.println();
    }
}

3.反转排序
顾名思义就是以相反的顺序把原有的数组的内容重新排序.
基本思想:把数组最后一个元素与第一个元素替换,倒数第二个元素与第二个元素替换,依次类推.

public class ReverseSort {
    public static void main(String [] args){
        int []array={10,20,30,40,50,60};
        ReverseSort sorter=new ReverseSort();
        sorter.sort(array);
    }

    private void sort(int[] array) {
        System.out.println("数组原有内容: ");
        showArray(array);
        int temp;
        int len=array.length;
        for (int i=0;i<len/2;i++){
            temp=array[i];
            array[i]=array[len-1-i];
            array[len-1-i]=temp;
        }
        System.out.println("数组反转后内容: ");
        showArray(array);
    }

    public void showArray(int[] array) {
       for (int i:array){
           System.out.print("\t"+i);
       }
        System.out.println();
    }
}