【JAVA基础】14 数组

1. 数组高级冒泡排序原理图解

画图演示
- 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

需求：数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。

package com.heima.array;

public class Demo1_Array {

    /**
     数组元素：{24, 69, 80, 57, 13} 请对数组元素进行排序。

           冒泡排序
               相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
     */
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        bubbleSort(arr);
        print(arr);
    }
    
    public static void bubbleSort(int[] arr) {
        for(int i = 0; i < arr.length -1 ; i++) { // 外循环只需要比较arr.length-1次就行了
            for(int j = 0; j < arr.length - i - 1; j++) {  // -1 是为了防止索引越界异常,-i 是为了
                if(arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }

    public static void print(int[] arr) {
        for(int i = 0;i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }

}

冒泡排序实例

2. 数组高级选择排序原理图解

画图演示
- 需求：
  - 数组元素：{24, 69, 80, 57, 13}
  - 请对数组元素进行排序。
  - 选择排序
    - 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

数组高级选择排序代码实现

package com.heima.array;

public class Demo1_Array {

    /**
    每轮固定首位，一轮下来获取最小值在首位
     */
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        selectSort(arr);
        print(arr);
    }
    


    public static void print(int[] arr) {
        for(int i = 0;i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }
    
    public static void selectSort(int[] arr) {
        for(int i = 0; i < arr.length -1 ; i++) { // 外循环只需要比较arr.length-1次就行了
            for(int j = i + 1; j < arr.length; j++) {  // -1 是为了防止索引越界异常
                if(arr[i] > arr[j]) {
                    int tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }

}

View Code

3. 数组高级二分查找原理图解

画图演示
- 二分查找
- 前提：数组元素有序

数组高级二分查找代码

package com.heima.array;

public class Demo2_Array {

    /**
    数组高级二分查找
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 88));
        System.out.println(getIndex(arr, 10));
    }
    
    /*
     * 二分查找
     * 返回值类型：int（索引位置）
     * 参数列表：int[] arr,int value
     */
    public static int getIndex(int[] arr,int value){
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {  // 当中间值不等于要找的值，就开始循环查找
            if(arr[mid] < value) { // 当中间值小于要找的值
                min = mid + 1;     // 最小的索引改变
            } else if(arr[mid] > value){  // 当中间值大于要找的值
                max = mid - 1;   // 最大的索引改变
            }
            mid = (min + max) / 2;  // 无论最大还是最小改变，都要重新更新中间索引
            
            if(min > max) { // 如果最小索引大于最大索引，就没有找到的可能性了
                return -1;
            }
        }
        return mid;
    }

}

View Code

注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

4. Arrays类的概述和方法使用

Arrays类概述
- 针对数组进行操作的工具类。
- 提供了排序，查找等功能。
- 还包含一个允许将数组作为列表来查看的静态工厂。

成员方法

public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

package com.heima.array;

import java.util.Arrays;

public class Demo3_Arrays {

    /**
     public static String toString(int[] a)

    public static void sort(int[] a)

    public static int binarySearch(int[] a,int key)
     */
    public static void main(String[] args) {
        int[] arr = {33,22,11,44,66,55};
        System.out.println(Arrays.toString(arr)); // 数组转字符串
        
        Arrays.sort(arr);      // 排序
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr, 44));  //二分查找
        System.out.println(Arrays.binarySearch(arr, 77)); 
    }

}

View Code

5. 基本类型包装类的概述

为什么会有基本类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
基本类型和包装类的对应
- byte Byte
- short Short
- int Integer
- long Long
- float Float
- double Double
- char Character
- boolean Boolean
基本数据类型包装类有八种，其中其中都有 parseXxx 的方法，可以将这七种的字符串表现形式转换成基本数据类型
char 的包装类 Character 中没有 parseXxx 的方法
- 因为char 只有一个字符，字符串的长度（>0）。
- 字符串到字符的转换通过 toCharArray() 就可以把字符串转换为字符数组

6. Integer类的概述和构造方法

Integer类概述
- Integer 类在对象中包装了一个基本类型 int 的值。
- Integer 类的对象包含一个 int 类型的字段。
- 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换。
- 还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法
- public Integer(int value)
  - 构造一个新分配的Integer对象，value表示指定的int值
- public Integer(String s)
  - 构造一个新分配的Integer对象，s表示指定的值

案例演示

使用构造方法创建对象

package com.heima.wrapclass;

public class Demo1_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Integer i = new Integer(10);
        System.out.println(i);
        
        Integer j = new Integer("100");
        System.out.println(j);
        
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }

}

View Code

7. String和int类型的相互转换

int --> String
- 将int值和""进行拼接
- String类的valueOf方法，将int值转换成String
  - public static String valueOf(int i)
- 通过Integer包装类中的toString()方法
  - int -- Integer -- String，先生成Integer对象，再调用toString方法
  - 直接使用Integer的toString的静态方法：public static String toString(int i)(Integer类的静态方法)
String --> int
- 通过将String转换成Integer对象，得到int
  - String -- Integer -- int
- 通过Integer类的静态方法parseInt方法，将字符串参数作为有符号的十进制整数进行解析。
  - public static int parseInt(String s)

package com.heima.wrapclass;

public class Demo2_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int i = 10;
        int2String(i);
        
        String s = "11";
        string2Int(s);
    }
    
    public static void int2String(int i) {
        // 第一种，通过"" 拼接变成字符串。 推荐用
        System.out.println(i + "");
        
        // 第二种，通过String类的 valueOf方法。  推荐用
        System.out.println(String.valueOf(i));
        
        // 第三种：通过Integer包装类中的toString()方法
        //int -- Integer -- String(Integer类的toString方法())
        System.out.println(Integer.toString(i));
    }
    
    public static void string2Int(String s) {
        // 第一种：通过将String转换成Integer对象，得到int
        // String -- Integer -- int
        Integer i = new Integer(s);
        System.out.println(i.intValue());
    
        
        // 第二种：推荐
        // public static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析。
        System.out.println(Integer.parseInt(s));
    }

}

String和int的转换示例

8. JDK5的新特性自动装箱和拆箱

JDK5的新特性
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型

案例演示

JDK5的新特性自动装箱和拆箱

Integer ii = 100;
ii += 200;

package com.heima.wrapclass;

public class Demo3_JDK5 {
    public static void main(String[] args) {
        
        // 手动装箱
        int x = 100;
        Integer i1 = new Integer(x);
        
        // 自动装箱
        Integer i2 = 100;
        System.out.println(i2);
        
        
        //手动拆箱
        int y = i2.intValue();
        System.out.println(y);
        
        
        // 自动拆箱
        int z = i1 + 200;
        System.out.println(z);
    }
}

View Code

注意事项
- 在使用时，Integer x = null；底层x调用intValue，但是x是null，null调用方法就会出现 NullPointerException（空指针异常）。
- 建议先判断是否为null，然后再使用。
- ```
package com.heima.wrapclass;

public class Demo3_JDK5 {
    public static void main(String[] args) {
        Integer i = null;
        int y = i + 100;
        
    }
}
```
  View Code

9. Integer的面试题

Integer的面试题

看程序写结果

package com.heima.wrapclass;

import java.lang.Integer.IntegerCache;

public class Demo4_Integer {

 
    public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);  // 输出false
        System.out.println(i1.equals(i2));  // 输出true
        /*
         * i1 == i2, 比较地址值是否相同
         * 
         * 
         * i1.equals
         * 比较此对象与指定对象。
         * 当且仅当参数不为null，并且是一个与该对象包含相同int值的Integer对象时，结果为true
         */
        
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);  // 输出false
        System.out.println(i3.equals(i4));  // 输出true
        
        
        
        System.out.println("自动装箱，自动拆箱");
        Integer i5 = 97;
        Integer i6 = 97;
        System.out.println(i5 == i6);  // 输出 true。
        System.out.println(i5.equals(i6));  // 输出true
        
        Integer i7 = 197;
        Integer i8 = 197;
        System.out.println(i7 == i8);  // 输出 false
        System.out.println(i7.equals(i8));  // 输出true
        
        /*
         * -128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新对象，而是从常量池中获取
         * 如果超过了byte取值范围，就会再创建对象
         * 
         *  public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)  //i>=-128 && i<127
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);  // 不在[-128,127]区间范围内，就直接重新创建Integer对象
        }

         * 
         * 
         * 
         */
        
    }

}

posted on 2020-05-08 14:55 Zoe233 阅读(181) 评论(0) 编辑收藏举报