javaSE 3

数组

数组是一个容器, 里面可以存储一组相同的数据类型(是一种引用数据类型,是一个对象)

数组中既可以存储基本数据类型, 也可以存储引用数据类型(看声明时定义的类型)

数组在创建时,必须要给定长度,创建后长度不可以改变 数组中的元素在存储中是连续的

数组的声明和创建

package day1;
​
import com.sun.prism.shader.Solid_TextureYV12_AlphaTest_Loader;
​
import java.util.Arrays;
​
public class Demo1 {
    /*
    数组的声明和创建:
    */
    public static void main(String[] args) {
        //数组的声明
        int a[],e,f;//a是声明的一个数组,而e,f是两个int变量
        int[]  b,c,d;//b,c,d都是数组,推荐使用这种
        //数组的创建,三种方式
        int[] g = new int [5];//相当于在内存中创建了一个有5个空间的区域,同时为这5个空间赋默认值0
        System.out.println(Arrays.toString(g));//[0, 0, 0, 0, 0]
        //toString 是把对象以 字符串 的形式输出
​
        int[] j = {1,2,3,4,5,6,7};//{ }中给几个元素, 数组的长度就是几
        System.out.println(Arrays.toString(j));//[1, 2, 3, 4, 5, 6, 7]
​
        int[] i = new int[]{1,2,3};//不常用
        System.out.println(Arrays.toString(i));//[1, 2, 3]
​
​
    }
}

​

数组的访问: 遍历和迭代

数组 [0,0,0,0,0]

索引  0 1 2 3 4

索引(index)是数组中的编号,都是整数(int类型),从0开始,而不是1开始,最大索引为长度-1 访问数组元素: 数组名[索引]

数组遍历,就是对数组中的每一个元素进行访问,可以使用循环      

例如 找最大值 判断数组中是否包含某个值

数组长度: 数组名.length

package day1;
import sun.security.util.Length;
import java.util.Arrays;
​
public class Demo2 {
   public static void main(String[] args) {
       float[] a = new float[5];
       System.out.println(Arrays.toString(a));
       String[] b = new String[5];
       System.out.println(Arrays.toString(b));
       int[] arr= new int[5];
             arr[1]=1;
             arr[0]=5;
             arr[2]=4;
             arr[4]=3;
             arr[3]=2;
       //数组元素的访问
       System.out.print(arr[0]);
       System.out.print(arr[1]);
       System.out.print(arr[2]);
       System.out.print(arr[3]);
       System.out.print(arr[4]);//514237
​
       /*
      数组的遍历
       */
       int[] c= {1,2,3,4,5,6,7};
              // 0 1 2 3 4 5 6
       //数组长度: 数组名.length
       System.out.println(c.length);
       for (int i = 0; i < c.length; i++) {
           //可以灵活的控制开始和结束
           System.out.println(c[i]);
       }​
   }
}

增强for循环

 //增强for循环(无法控制开始和结束, 只适合从开始遍历到结束的情况)
        for(int temp:c){
            //其中j是要遍历的数组, 每次会从循环中取出一个数,赋值给左边定义的变量temp,直到数组中所有的元素遍历完成,循环结束
            System.out.println(temp);
        }

​

冒泡排序

思想:每一次取出数组中相邻的两个元素进行比较, 把较大的向后移动 只需要循环length次就可以完全排好序

package day1;
import sun.applet.Main;
import java.util.Arrays;
​
public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {5,4,3,2,1};
        for (int i = 0; i < arr.length-1; i++) {
            //外层循环 控制循环的次数
            for (int j = 0; j < arr.length-i; j++) {
                //内层循环, 控制便数
                if(arr[j]>arr[j+1]){
              //将两个位置的值进行交换 采用临时变量temp的方法
                    int temp =arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]= temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
​

选择排序

       从数组的第一位开始,认为第一位是最小(大)值, 用第一位和谋面每一位进行比较 如果后面有小于第一位的, 就用后面小的在与之后的数进行比较,直到找到这组数中最小的,与第一位进行交换 ,然后从第二位开始重复操作

package day1;
import java.util.Arrays;
​
public class Demo4 {
    //选择排序
    public static void main(String[] args) {
        int[] arr={5,4,3,2,1};
        //         0 1 2 3 4
​
        for (int i = 0; i < arr.length; i++) {
            int minindex = i ;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[minindex]>arr[j]){
                 minindex =j;//记录最小值的位置,但是不交换
                }
            }
            //把最小值的位置与i的位置进行交换 只交换一次
               int temp=arr[i];
               arr[i]= arr[minindex];
               arr[minindex]=temp;
        }
         System.out.println(Arrays.toString(arr));
    }
}
​

debug调试

跟踪程序运行过程

操作: ----设置断点(程序开始要调试的位置)

----用debug格式启动程序,程序会停止在断点那一行

----调试程序

     步调 点击一次执行一次 快捷键F8 ;

     resume释放程序 当我们在某行找到问题后,后面步调试,点击此按键后让后面的程序直接执行完成 快捷键F9)

     step into 进入方法

     step out 跳出方法

----取消断点

可以使用下面程序简单调试

package day1;
​
public class Demo5 {
    public static void main(String[] args) {
            int a = 10;
            int b = 0;
            // int c = a/b;
            //System.out.println(c);
            //Demo2.test(a,b);//进入到方法内部
            //System.out.println(1111);
​
            for (int i = 0; i <10 ; i++) {
                System.out.println(i);
            }
        }
        public static void test(int x,int y) {
            int m = x / y;
            System.out.println(m); //离开方法
        }
}

二维数组

数组的数组 即二维数组中的每一个元素 还是一个一维数组

一维数组和二维数组的区别:

int[] a ; 一维数组 int a[]; int[] [] b;二维数组 int b[] [];

二维数组的声明和创建

package day1;
 public class Demo6 {
 public static void main(String[] args) {
        /*
            二维数组声明,创建 [3][5]
            3-表示二维数组的长度是3
            5-表示二维数组中的一维数组长度是5
            {{0,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}}
         */
        int[][] a = new int[3][5];
​
        int[][] b = new int[][]{{1,2,3},{4,5,6},{7,8,9}}; //3 3
​
        int[][] c = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
        //            0 1 2   0 1 2   0 1 2   0  1  2     一维数组的下标
        //              0       1       2        3        二维数组的下标(索引)

二维数组元素的访问和遍历

/*
         如果想拿到5这个元素 对应数组c中就是  c[1][1]
         System.out.println(c[1][1]);
         System.out.println(c[0][2]);
         如果想要改变值 c[1][1] = 55;
*/
​
        //二维数组遍历
        // 先遍历二维数组.每次取出一个一维数组, 然后再遍历一维数组
        for (int i = 0; i < c.length; i++) {
            //c[i] 取出第i个一维数组
            for (int j = 0; j <c[i].length ; j++) {
                System.out.print(c[i][j]+"\t");  //"\t是空格"
            }
            System.out.println();
        }
    }
 }