1. 技术文章
  2. 笔记(课3)

笔记(课3)

由 梦想与她 提交于 2019-11-27 05:59:32

一阶段：第三天：数组+二维数组（7.26）

一.数组

1.1概述

  1. 系统对初始值分配规则如下：
    a.整数型为0
    b.浮点型为0.0
    c.字符型为‘\u0000’(不同的系统平台显示结果不同)
    d.布尔类型为false
    e.引用类型为null
    静态初始化是在程序编译时就初始化好了的，动态初始化是在程序运行是才动态分配内存空间。
  2. 如果超出范围出现异常 java.lang.ArrayIndexOutOfBoundsException
  3. 遍历数组 ：方式一：简单for循环 方式二：增强for循环（foreach）无法使用下标
  4. 数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存空间，只有当这个引用指向有效的空间时，才可以通过引用去操作真正数组中的元素数组的引用变量存储在栈空间中，而真正的数组数据存储在堆
  5. 基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

空间中。

1.2数组的排序

1.2.1 冒泡排序

排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）

class ArraySortedDemo01 { 
　　public static void main(String[] args) { 
　　　　int[] arr = {23,54,65,3,5,2,87}; 
　　　　//以升序为例 
　　　　//外层循环：控制比较的轮数 
　　　　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 temp = arr[j]; 
　　　　　　　　　　arr[j] = arr[j + 1]; 
　　　　　　　　　　arr[j + 1] = temp; 
　　　　　　　　} 
　　　　　　} 
　　　　}
　　　　for(int num:arr) { 
　　　　　　System.out.println(num); 
　　　　} 
　　} 
}

1.2.2选择排序

排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较

class ArraySortedDemo02 { 
　　public static void main(String[] args) { 　
　　　　int[] arr = {23,54,65,3,5,2,87};
　　　　 //以升序为例 
　　　　 //外层循环：控制比较的轮数
　　　　  for(int i = 0;i < arr.length ‐ 1;i++) { 
　　　　  　　//内层循环:控制每一轮比较的次数，参与比较的下标
　　　　  　　 for(int j = i + 1;j < arr.length;j++) { 
　　　　  　　 　　//交换位置 
　　　　  　　 　　if(arr[i] > arr[j]) { 
　　　　  　　 　　　　int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
　　　　  　　 　　 } 
　　　　  　　 } 
　　　　  }
　　　　  for(int num:arr) { 
　　　　  　　System.out.println(num); 
　　　　  } 
　　} 
}

1.2.3插入排序

排序思路：有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序

public class Demo8 {
    public static void main(String[] args) {
        int[] arr={12,5,13,7,9};
        System.out.println("插入排序之前");
        for (int n:arr){
            System.out.print(n+" ");
        }
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            int pos=i;//插入的位置
            int curr=arr[i];
            for (int j = i-1;j>=0 ; j--) {
                if (arr[j]>curr){
                    arr[j+1]=arr[j];
                    pos--;
                }else {
                    break;//跳出循环
                }
            }
            if(pos!=i){
                arr[pos]=curr;
            }
        }
        System.out.println("插入排序之后");
        for (int n:arr){
            System.out.print(n+" ");
        }
    }
}

1.3数组的查找

1.3.1顺序查找

查找思路：遍历这个数组，依次把每一位元素和要查找的数据进行比较

class ArraySearchDemo01 { 
　　public static void main(String[] args) { 
　　　　int[] arr = {23,54,65,3,5,2,87};
　　　　 //需求：查找65在数组中的位置 
　　　　 int key = 65; 
　　　　 for(int i = 0;i < arr.length;i++) { 
　　　　 　　if(key == arr[i]) { 
　　　　 　　　　System.out.println(i); 
　　　　 　　} 
　　　　 } 
　　} 
}

1.3.２二分法查找

查找思路：前提是数组是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率 将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找

class ArraySearchDemo02 { 
　　public static void main(String[] args) { 
　　　　int[] arr = {12,43,54,65,87,88,90,343}; 
　　　　//待查找的元素 
　　　　int key = 88; 
　　　　//相应的下标 
　　　　int left = 0; 
　　　　int right = arr.length ‐ 1; 
　　　　while(left <= right) {
　　　　　　 //中间下标 
　　　　　　 int middle = (left + right) / 2;
　　　　　　 //取整 
　　　　　　 if(arr[middle] > key) { 
　　　　　　 　　right = middle ‐ 1; 
　　　　　　 } else if(arr[middle] < key) { 
　　　　　　 　　left = middle + 1; 
　　　　　　 } else { 
　　　　　　 　　System.out.println(middle); break; 
　　　　　　 } 
　　　　} 
　　} 
}

二.多维数组

2.1Arrays工具类

作用：主要用于对数组进行排序，查找，填充，比较等的操作

public class Demo1 {
    public static void main(String[] args) {
        sort();
        binarySearch();
        copyOf();
        copyIfRange();
        equals();
        fill();
    }
    //sort 排序
    public static void sort(){
        int[] nums={10,5,8,15,9,20,19};
        System.out.println("排序之前"+Arrays.toString(nums));
        Arrays.sort(nums);
        System.out.println("排序之后"+Arrays.toString(nums));
    }
    //binary search 二分查找
    public static void binarySearch() {
        int[] nums = {10, 5, 8, 15, 9, 20, 19};
        Arrays.sort(nums);
        //搜索
        int i=Arrays.binarySearch(nums, 12);
        System.out.println("下标:"+i);
    }
    //copyOf 复制
    public static void copyOf() {
        int[] nums = {10, 5, 8, 15, 9, 20, 19};
        int[] arr=Arrays.copyOf(nums, 3);
        System.out.println(Arrays.toString(arr));
    }
    //copyIfRange 范围复制
    public static void copyIfRange(){
        int[] nums = {10, 5, 8, 15, 9, 20, 19};
        int[] arr=Arrays.copyOfRange(nums, 2, 5);//含头不含尾
        System.out.println(Arrays.toString(arr));
    }
    //比较 equals
    public static void equals(){
        int[] nums1 = {10, 5, 8, 15, 9, 20, 19};
        int[] nums2 = {10, 5, 8, 15, 9, 20, 19};
        boolean b=Arrays.equals(nums1, nums2);
        System.out.println("结果"+b);
    }
    //填充 fill
    public static void fill(){
        int[] nums1 = {10, 5, 8, 15, 9, 20, 19};
        Arrays.fill(nums1, 100);
        System.out.println(Arrays.toString(nums1));
    }
}

2.2方法

  1. Java中的方法传参采用的是传值的方式。
    （1）基本类型传递的实际数据 ,即实参值不随方法参与而改变
    （2）引用类型传递的是地址,即实参值会随方法参与而改变，变为方法中的运行结果的值
  2. 可变参数（不定长参数）： 在设计方法时，方法的形参的个数是不确定的
    语法：
    类型… 变量名称
    例如：int… num
    好处：不用创建数组，直接写数组元素
int[] nums和int...nums
注意事项：(1)一个方法只能由一个可变参数
         (2)可变参数只能在方法参数列表的最后
         (3)不定长的参数在进行使用的时候被当做数组来进行处理 
public class Demo3 {
    public static void main(String[] args) {
        int[] nums={10,20,30,40,50};
        show(nums);
        show1(nums);
        show1(100,200,300,400,500);//100,200,300，400,500作为数组元素
        show2(100,200,300,400,500);//100,200,300，400,500作为数组元素
        show3("上海","北京");//100,200,300，400,500作为数组元素
    }
    public static void show(int[] nums){
        for (int num:nums){
            System.out.println(num);
        }
    }
    public static void show1(int... nums){
        for (int num:nums){
            System.out.println(num);
        }
    }
    public static void show2(int n,int... nums){
        for (int num:nums){
            System.out.println(num);
        }
    }
    public static void show3(String... cities){
        for (String city:cities){
            System.out.println(city);
        }
    }
}

2.3二维数组

  1. 数组特殊的初始化：
int[][]nums5=newint[2][];
nums5[0]=newint[3];
nums5[1]=newint[4];
二维数组在内存中以一维数组的形式存储
第一个[]是表示连接的是几个一维数组，
第二个[]是表示每个一维数组里有几个元素
  1. 二维数组的遍历
//增强for循环 
for(int[] subArr1:arr) { 
　　for(int n:subArr1) { 
　　　　System.out.println(n); 
　　} 
}

2.4调试技巧

  1. 添加断点：在前方点一下，出现红色圆点
 F8 单步跳过 step over
 F7 单步进入 step into
 Alt+Shift+F7 强制单步进入 force step into(查看不在该类中的方法)
 Shift+F8 单步退出 step out
 F9 继续执行 resume programe
 public class Demo6 {
    public static void main(String[] args) {
        System.out.println("hello");
        show();
        System.out.println("你好");
    }
    public static void show(){
        for (int i = 0; i <10 ; i++) {
            System.out.println(i);
        }
    }
}
  1. JavaDoc注释：用来注释类、属性和方法等
    使用语法 /** …*/
    在这里插入图片描述
标签
num
arr
数组
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!