day05 笔记----java数组

Dear 丶 2022-02-16 12:53 322阅读 0赞

Java数组1

笔记：
    1.for：
    2.break：跳出循环
      continue：跳过本次循环中剩余的语句进入下一次循环
    3.三种基本循环更适应情况：
    	4.1 while：要素1与要素3不同时  首选while
    	4.2 do..while:要素1与要素3相同时  首选 do...while
    	4.3 for:固定次数循环，应用率最高
    	循环选择的规则：
    		1.固定次数-------------------------------直接用for
    		2.不固定次数
    			1)while：要素1与要素3不同时--------直接while
    			2)do..while:要素1与要素3相同时-----直接 do...while	
    4.嵌套循环：\t 水平制表位   固定占8位
    	4.1 循环中套循环，一般多行多列使用，外层控制行，内层控制列
    	4.2 执行规则  外层循环走一次  内存循环走所有次 
    	4.3 建议：循环层数越少越好，能用一层就不用两层，能用两层就不用三层，若需求必须通过三层以上的循环来解决，说明设计有问题
    	4.4 break只能跳出一层  (if循环)
    	for(){
    		for(){
    			if(){
    				break;
    				}
    		}
    }
    5.程序+算法+数据结构
    	5.1 算法：解决问题的流程/步骤(顺序，分支，循环)
    	5.2 数据结构：将数据按照某种特定的结构保存(数怎么存)
    		设计良好的、合理的数据结构会导致好的算法
    6.数组:  数组是最基本的一种数据结构
        1）是一种数据类型（应用类型）
        2）相同数据类型元素的集合
        3）数组的定义         
    	**数据类型[] 数据名 = new 数据类型[大小]**
           int a; //声明整型变量
           int[] a;//声明整型数组变量
           int a = 5;
           int[] = new int[5];//声明整型数组a，包含5个元素 每个元素都是int类型，默认值为0
           double[] d = new double[10];//声明浮点型数组b，每个元素都是double类型，默认值为0
           boolean[] c = new boolean[26];//声明bool型数组b，每个元素都是boolean类型，默认值为0
        4）数组的初始化
            int[] arr = new int[4];// 0，0,0,0
            int[] arr = {1,2,3,4};//1,2,3,4
            int[] arr = new int[]{1,2,3,4};//1,2,3,4
    
            int[] arr;
            arr = {};//编译错误，此方法只能声明的同事初始化
            arr = new int[]{1,2,3,4};//正确
    
        5）数组的访问
            1）通过（数组名.length）来获取数组的长度（元素的个数）
                int[] arr = new int[4];
                System.out.println(arr.length);//4
            2）通过下标或索引来访问数组中的元素
                小标从0开始，最大到（数组的长度减一）
    
                int[] arr = new int[3];//0,0,0
                //给第二个数赋值为100
                arr[1] = 100;
                arr[3] = 400;//数组下标越界异常
                arr[0].............表示arr中的第1个元素
                arr[1.............表示arr中的第2个元素
                arr[2].............表示arr中的第3个元素
                System.out.println(arr[]);//输出arr中最后一个元素
                System.out.println(arr.length-1);
    
                int a = 0;
                int b = 0;
                int c = 0;
                //给第二个数赋值为100
                b = 100；
        6）数组的遍历
    
                int[] arr = new int[10];
                for(int i = 0 ;i < arr.length ; i ++){//for(int i = 0;i < 10; i++);
                    arr[i] = 100;
                }
                for(int i = 0 ; i < arr.length ; i ++){
                    System.out.println(arr[i]);//顺序输出
                }
                for(int i =(rr.length);i >=0 ; i --){
                    System.out.println(arr[i]);.//倒序输出
                }
    
                arr[0] = 100;
                arr[1] = 100;
                arr[2] = 100;
                    .
                    .
                    .
                .arr[9] = 100;
        7）生成随机数
            arr[i] = (int)(math.random()*100);//
            util也有随机数的方法
    
    
        8）找最大值算法：
            int[] arr = {23,45,67,3}
            1.设第1个元素为最大值
            int max = arr[0];
            2.遍历剩余元素,将剩余元素与max进行比较
             余元素大于max，则修改max的值为较大的
                for(int i = 1; i < arr.length;i++){
                    if(arr[i]>max){
                        max = arr[i];
                    }
    
                }
        9）找最小值算法：
            nt[] arr = {23,45,67,3}
            1.设第1个元素为最小值
            int min = arr[0];
            2.遍历剩余元素,将剩余元素与min进行比较
             余元素小于min，则修改min的值为较小的
                for(int i = 1; i < arr.length;i++){
                    if(arr[i]<min ){
                        min  = arr[i];
                    }
    				
    			}

Java数组2

1.数组的复制：
        1) Systemarraycopy.()方法可以实现数组的复制  System.arraycopy(a,0,a1,0,4); 
                int[] a ={120,20,30,40,50};
                int[] a1 =new int[6];
                System.arraycopy(a,0,a1,0,4);
                for(int i=0;i<a1.length;i++) {
                    System.out.println(a1[i]);
                }
                //a:源数组  
                //1:源数组的起始下标 
                //a1:目标数组 
                //0:目标数组的起始下标 
                //4:要复制的元素个数
        
        2) Arrays.copyOf方法用于数组的复制  int[] a1=Arrays.copyOf(a,6);
                类型[] newArray = Arrays.copyOf(类型[] original，int newLength)
                int[] a={10,20,30,45};
                int[] a1=Arrays.copyOf(a,6);
                a1的元素为：10,20,30,45,0,0
        3) 数组的扩容   （创建了一个新的数组，把原始的数据复制过去
                int[] a = {12,23,56,45,47};）
                a = Arrays.copyOf(a, a.length+1);
                for(int i=0;i<a.length;i++) {
                    System.out.println(a[i]);
                }
    
    2.排序：（交换次数越少，效率越高）
        1)不同的数据用不同的方法，效率也不同
        2）最最快的排序
            Arrays.sort(arr);//升序排列
        3）冒泡排序（面试题）
            3.1.1 五个数冒四轮
            3.1.2 每一轮都是从第一个元素开始冒
                 每一次都是和它的下一个元素比
            3.1.3 冒出来就不和它比了
    
            int [] arr= {45,35,1,8};//升序排列（1，8,35,45）
            for(int i=0;i<arr.length-1;i++){//控制轮
                //每一轮
                for(int j=0;j<arr.length -1-i;j++){//控制次
                    //每一次
                    if(arr[j]>arr[j+1]){// 
                    int t =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;                    
                    }
                }
            }     
    
                                arr.length -1-i
                            i=0  比3次
                            i=1  比2次
                            i=2 比1次
            流程：
            第一轮：
                45和23比，换，23,45,1,8
                45和1比，换，23,1,45,8
                45和8比，换，23,1,8,45  ------------45冒出来了
            第二轮：
                23和1比，换，1,23,6,45
                23和8比，换，1,8,23,45  ------------23冒出来了
            第三轮：
                1和8比，不换            ------------8冒出来了
    3.方法：
        1)封装语段特定的逻辑功能
        2)方法尽可能独立，只干一件事
        3)方法可以被反复多次的调用
        4)方法可以减少代码的重复，有利于代码的维护，有利于团队的协作
    4.方法的定义：
        4.1 方法用于封装一个特定的功能
        4.2 定义方法的五个要素：
        public static    int       sum        (int numl,int num1){
            修饰词     返回值类型   方法名             参数列表
            //方法体
        }
            @ 修饰词  
            @ 返回值类型     
                1）方法可以有返回值也可以没有返回值 
                    1.若无返回值，则返回至类型写成void 
                    2.若有返回值，则返回值类型写成具体的数据类型即可
                2）何时有返回值，何时没有返回值
                    方法执行完后
                    1.还需要用到方法中的某个数据-----有返回值
                        int  a = scan.  nextInt();-----有返回值
                    2.不还需要用到方法中的某个数据-----无返回值
                        int[] a1= Arrays.copyOf(arr);-------- 无返回值
            @方法名
            @参数列表
                方法可以有参数也可以无参数，有参数可以是方法更灵活
                double c= Math.random();//0.0到0.9999999999999.......
                double c= Math.random(1,1000);
                double c= Math.random(0,99);
                double c= Math.random(20,45);
            @方法体
        注意的要点：
            1）有残必须传参，并且参数类型必须匹配
            2）有返回值必须return，并且return后的值必须与返回值匹配
            3）调用方的变量名与方法中的变量名------没有任何关系
            4）方法可以嵌套调用的
    5.方法的调用：
        1)无返回值：方法名（有参传参）
        2)有返回值：数据类型 变量 = 方法名（有参传参）;
    6.return ：
        1）return num1,num2;
            1.1 结束方法的执行
            1.2 返回结果给调用方
        2） return;
            2.1  结束方法的执行------用在无返回值的方法中