Java学习 11.23

Java学习 数组

1.1 junit的单元测试

我们现在代码测试的时候都是创建一个类 添加一个main函数、但是一个类只能有一个main函数。假如我们需要测试很多内容，就会出现一个问题 需要创建很多的类。很麻烦。
所以我们可以使用单元测试，相当于一个类可以写n个函数并且能调用执行。
​
A 创建一个类 注意一定不能叫Test（因为我们要用的第三方的类也叫Test）
B 在类中写一个公共无参数的函数
C 在函数上面添加一个@Test注解
D 通过智能纠正导入需要的依赖
    
package com.aaa.day03.test;
import org.junit.Test;
public class JavaTest {
    @Test
    public void test(){
​
    }
}    
import org.junit.Test;  代表导入其他的类，java中语法规定，如果两个类不在同一个包中，此时需要使用的时候 就需要import 导入

1.2 数组的概述

数组（Array）是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。

1.3 数组的创建

  /**
     *  数组的创建
     */
    @Test
    public void test(){
​
        /*   第一种方式  初始容器
             创建一个初始容量是5的类型的数组 并且赋值给了 arr1
        *   注意 java中的数组 创建的是什么类型 就只能存储什么类型的数据
        * */
        int[]  arr1 = new int[5];
        boolean[]  arr2 = new boolean[8];
        String[]  arr3 = new String[20];
        
​
        /*变种写法  【】写到变量名的后面 不推荐这个写法 因为表意不明却 但是很多官方文档还是这样写的  */
        char  arr4[] = new char[6];
​
        /* 第二种方式  初始值*/
        // 创建了int类型数组 初始容量是5 并且每个位置的数据依次是  30,50,80,90,60
        int[]  arr5 = new int[]{30,50,80,90,60};
​
        /* 第三种方式  字面量*/
        String[]  arr6 = {"zhangsan","李四","王五"};
​
    }
​
总结：
    A    数据类型[]  名字 = new 数据类型[容量];
    B    数据类型[]  名字 = new 数据类型[]{ 该类型的值   };
    C    数据类型[]  名字 = {该类型的值 };
​

1.4 数组数据的存取

@Test
    public void test1(){
​
        int[] arr = new int[5];
​
        // 数组的数据存取都是操作索引值/下标
        /*取*/
        /*从arr数组中获取索引值为3的数据 赋值给 a*/
        int  a = arr[3];
        System.out.println(a);
​
        //存
        arr[0] = 666;
        System.out.println(arr[0]);
​
        int  len =  arr.length;
        System.out.println(len);
​
        // arr.fori
​
    }

1.5 java数组的越界异常

java中的数组是定型和定容的。
定型：设定什么类型的数据就只能存储什么类型的数据
     int[] arr = {123,345,"haha"};
定容：设定初始容量是多少就只能存储多少个数据
    
如果超出容量范围就会出现数组越界异常
​
​
java.lang.ArrayIndexOutOfBoundsException: 10              异常信息
                                                          
    at com.aaa.day03.test.JavaTest.test2(JavaTest.java:59)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
    at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
    at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
   
首先看是什么异常
​

1.6 java数据扩容

因为数组就是用来存储数据的，但是java的数组容量固定，一旦超出容量，就会出现数组越界异常。
但是我们 后面要存储的都是动态数据 （不固定 不知道有多少个）
此时我们创建了一个数组1一个亿容量 发现只有三个数据要存。浪费
如果我们初始容量创建了8个 ，但是有十万个数据要存。装不下。
​
所以我们java中的数组就有一个扩容的操作。
@Test
    public void test2(){
​
        int[] arr = {10,20,30};
​
        // 1 创建一个更大的数组
        int[] newArr = new int[arr.length*2];
​
        // 2 将老数组的数据添加到新数组中
        /*newArr[0] = arr[0];
        newArr[1] = arr[1];
        newArr[2] = arr[2];*/
​
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
​
        newArr[3] = 40;
​
    }

1.7 冒泡排序

 @Test
    public void test3(){
​
        int[] arr = {6,3,4,2,8,7,5,1};
​
        int len = arr.length;
​
​
        for (int i = 1; i < len; i++) {
            for(int j=0;j<len-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
​
        System.out.println(arr);
    }
​

1.8格式化输出

@Test
public void test4(){
     int[] arr = {6,5,4,8,12,4,45,321};
     System.out.println(arr);
}
此时输出的时候 输出的结果是：[I@22927a81  。我们想要的是输出数组的内容。以前也遇到过这个问题，重写类的toString函数，但是在这个地方重写的方式不能用，因为数组不是我们定义的类，所以也无法重写。
​
所以我们需要自己写一个逻辑代码解决这个问题：
​
@Test
    public void test4(){
​
        int[] arr = {6,5,4,8,12,4,45,321};
​
        String  str = "[";
        for (int i = 0; i < arr.length; i++) {
             str += arr[i];
             if(i == arr.length-1){
                 str += "]";
             }else{
                 str += ",";
             }
        }
​
        System.out.println(str);
​
    }

1.9 数组工具类封装

package com.aaa.day03.test;
​
public class ArrayTool {
​
    /**
     * 1将数组转换成字符串
     * @param arr  要转换的数组
     * @return     转换后的字符串
     */
    public static String toMyString(int[] arr){
​
        String  str = "[";
        for (int i = 0; i < arr.length; i++) {
            str += arr[i];
            if(i == arr.length-1){
                str += "]";
            }else{
                str += ",";
            }
        }
​
        return str;
    }
    /**
     * 2获取数组最大值的函数
     *
     **/
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
​
    /**
     * 3判断两个数组是否完全一致
     **/
    public static boolean  isSame(int[] arr1 , int[] arr2){
        if(arr1.length != arr2.length){
            return false;
        }
​
        for(int i=0;i<arr1.length;i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
​
    /**
     * 4获取某个数据在数组中首次出现的位置
     **/
    public static int indexOf(int[] arr , int  data){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == data){
                return i;
            }
        }
        return  -1;
    }
​
    /**
     * 5将数组进行排序
     **/
    public static void sort(int[] arr){
​
        int len = arr.length;
​
        for (int i = 1; i < len; i++) {
            for(int j=0;j<len-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
​
    }
}
​
​
​
​
​