Java”数组“常用操作小练习

数组的常规操作
1.默认初始化、动态初始化、静态初始化

        //默认初始化和动态初始化相结合
        //默认初始化
        String[] str=new String[4];
        //动态态初始化
        str[0]=new String("java:60分");
        str[1]=new String("python:70分");
        str[2]=new String("大数据:80分");
        str[3]=new String("人工智能:90分");
        //使用for循环打印输出
        for (int i=0;i<=str.length-1;i++) {
            System.out.println("第" + (i+1) + "门学科-----"+str[i]);
        }
        System.out.println();

        //静态初始化		数组元素之间用"逗号"分开，最后一个元素不需要”逗号“
        String[] strings={
                new String("java考了60分"),
                new String("python考了70分"),
                new String("大数据考了80分"),
                new String("人工智能考了90分")
        };
        //声明一个计数器
        int count=1;
        //使用foreach循环
        for (String arrStr: strings) {
            System.out.println( "第"+count+"门课程"+arrStr);
            count++;
        }

2.结合Arrays工具类的一些小练习

    //text1     数组的拷贝
        //静态初始化一个字符数组
        String[] a1={"北京","上海","重庆","天津","杭州"};
        //默认初始化一个长度为5的数组
        String[] a2=new String[5];
        
        //arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length)
        //              数据源     数据源起始      目标数组   目标数组起始   拷贝个数
        System.arraycopy(a1,0,a2,0,4);
        //打印输出 新数组中的元素
        System.out.println(Arrays.toString(a2));
        System.out.println();

    //text2     数组的排序
        //静态声明一组数据
        int[] a={12,9,15,31,24,100,56};
        //将数组中的元素从小到大排序
        Arrays.sort(a);
        //打印数组中的元素
        System.out.println(Arrays.toString(a));
        System.out.println();

    //text3     使用Arrays.binarySearch()实现二分法的查询,查询前提要将数组中的信息排好序
        int[] b={565,123,5131,156,12,53,0,98};
        //排序之前先输出一边
        System.out.println(Arrays.toString(b));
        //将数组中的元素从小到大排序
        Arrays.sort(b);
        //打印数组中的元素
        System.out.println(Arrays.toString(b));
        //返回该98在整个数组中的索引值
        System.out.println(Arrays.binarySearch(b,98));      
        System.out.println();

    //text4     数组中数据的填充        Arrays.fill(数组,起始值,结束值,具体数);
    	//静态声明一个数组
        int[] c={123,45,65,78,12,69};
        //将数组中的元素进行输出
        System.out.println(Arrays.toString(c));
        
        //数组数据的填充    注意不包含结束索引
        //Arrays.fill(数据源,填充的初始索引,填充的结束索引,填充的数据); 
        
        Arrays.fill(c,2,4,55);
        System.out.println(Arrays.toString(c));

问题：数组中的元素如果是自定义类（引用数据类型）,应如何做?
　　　注意:自定义类中没有实现内部比较器Comparable接口,数据的显示顺序为添加顺序。当实现内部比较器之后我们可以通过属性对其数组中的元素进行比较。

3.数组中存储自定义类　　
　　第一步：首先定义一个小小学生类。

//对学生类进行JavaBean封装
class Stundet implements  Comparable{   //Comparable   内部比较器
    private int id;         //编号
    private String name;    //姓名
    private int age;        //年龄
    //无参构造方法
    public  Stundet(){
    //有参构造方法
    }
    public Stundet(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //toString
    @Override
    public String toString() {
        return "{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    //实现内部比较器中的接口
    @Override
    public int compareTo(Object o) {
        Stundet stundet=(Stundet) o;
        //定义一个比较规则，按学生类中age属性进行比较，后期根据遍历顺序输出学生类信息
        if (this.age>stundet.age){
            return 1;
        }
        if (this.age<stundet.age){
            return -1;
        }
        return 0;
    }
}

第二步：开始定义我们的学生类信息，发现我们的英雄也需要不断地学习。

//测试学生类
        Stundet[] stundets={
                new Stundet(1001,"吕布",25),
                new Stundet(1002,"赵云",24),
                new Stundet(1003,"刘备",28),
                new Stundet(1004,"关羽",27),
                new Stundet(1005,"张飞",26),
                new Stundet(1009,"黄忠",60),
                new Stundet(1010,"马超",31),
                new Stundet(1006,"曹操",30),
                new Stundet(1007,"典韦",29),
                new Stundet(1008,"张辽",33)
        };

第三步：根据比较器接口方法中指定的规则，进行比较和输出。

		//使用Arrays工具类中的sort()排序方法,根据学生类中的age属性从小到大排序.
		Arrays.sort(stundets);
		//使用for-each循环进行遍历输出
        for (Stundet stus:stundets ) {
            System.out.println(stus);
        }

思考：集合中的元素只能存引用数据类型，那么集合里面有没有也需要实现比较器接口的集合呢？？？如果有,又会是那些具体的集合呢？？？

提升训练

4.冒泡排序

import java.util.Arrays;

/**
 * 测试冒泡排序
 */
public class MaoPaoTest {
    public static void main(String[] args) {
        //声明一个静态数组
        int[] value={12,56,94,31,58,65,76,25};
        yhmaopao(value);
        //循环该数组
        System.out.println(Arrays.toString(value));

    }
    public static  void yhmaopao(int[] arr){
        int tmpe;                         		//声明一个中间变量,用于值的交换
        for (int i=0;i<arr.length;i++){         //外层循环控制循环的轮数
            boolean flag=true;                  //定义一个布尔类型,用于判断循环的数是否是有序
            for (int j=0;j<arr.length-1-i;j++){ //内层循环控制循环的次数
                if (arr[j]>arr[j+1]){           //判断相邻的两个值谁大谁小
                    tmpe=arr[j];                //将大值赋值给中间变量
                    arr[j]=arr[j+1];            //将小值赋值给前者
                    arr[j+1]=tmpe;              //将中间变量的赋值给后者
                    flag=false;                 //循环结束后,如果不是有序数列则继续循环

                }
            }
            if (flag){                          //如果是有序数列则停止循环
                break;                          //结束方法的运行
            }

        }
    }
}

5.二分法查找(折半查找)

import java.util.Arrays;
/**
 * 测试二分法查询
 * 返回所要查找元素的索引位置
 */
public class ErFenArray {
    public static void main(String[] args) {
        //首先声明一个静态数组
        int[] arr={6,10,15,13,12,11,9,21,19,31};
        //排序  从小到大
        Arrays.sort(arr);
         //将排好顺序的数据打印输出
        System.out.println(Arrays.toString(arr));
        
        //调用折半方法    一定要将其排好顺序
        System.out.println(erfen(arr,31));

    }               	
    public static int erfen(int[] arr,int tmpe){	//方法中的形参,用来传入(源数组,源数组中的元素值)
        int zuo=0;               //最左边的索引下标 , 初始索引
        int you=arr.length-1;    //最右边的索引下标 ,结束索引
        while (zuo<=you){        //	循环条件		最左边的索引值要小于等于最右边的索引值
            int m=(zuo+you)/2;   //获取折半之后的索引值
            if (tmpe==arr[m]){   //如果输入的元素等于数组中折半之后索引值对应的元素,则直接返回该索引下标
                return m;
            }
            if(tmpe>arr[m]){     //如果输入的元素大于数组中折半之后索引值对应的元素 ,则将最左边的索引值进行移动,下标加1个单位.
                zuo=m+1;
            }
            if (tmpe<arr[m]){    //如果输入的元素小于数组中折半之后索引值对应的元素 ,则将最右边的索引值进行移动,下标减1个单位
                you=m-1;
            }
        }
        return -1;               //如果没有找到的话  直接返回-1
    }

}

6.补充二维数组初始化

 		// 默认定义二维数组
        int[][] arrs=new int[3][];
        //动态定义二维数组、静态定义一维数组
        arrs[0]=new int[5];
        arrs[1]=new int[2];
        arrs[2]=new int[1];
        //使用双层for循环,循环遍历二维数组中的一维数组元素
        for (int i=0;i<arrs.length;i++){
            for(int j=0;j<arrs[i].length;j++){
                System.out.print(arrs[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println();
        
        //静态初始化二维数组、并将一维数组直接静态初始化赋值
        int[][] arrs1={{12,35,49},{52,1,13,14},{321,456,987}};
        //输出第一个二维数组中,下标索引为1的元素
        System.out.println(arrs1[0][1]);
        //使用Arrays.toString循环遍历二维数组
        System.out.println(Arrays.toString(arrs1[0]));
        System.out.println(Arrays.toString(arrs1[1]));
        System.out.println(Arrays.toString(arrs1[2]));

注意：在获取数组中元素的长度时，一定明确是数组中的二维数组还是具体的一维数组。

		//以上文二维数组代码为例，分别获取数组长度		特别提醒：二维数组的索引也是从0开始的
		//获取arrs1的二维数组的长度
        System.out.println(arrs1.length);			//二维数组的长度为3
        //获取arrs1二维数组中的具体的一维数组的长度
        System.out.println(arrs1[1].length);		//该一维数组的长度为4

数组中的练习总结,暂时到此结束。

谢谢您的观看,如有提议请在评论区留言。