14.Java-Arrays(類)、基本型別包裝類、Integer(類)

孑孓莎發表於2020-12-17
Java型別

14.Java-Arrays(類)、基本型別包裝類、Integer(類)

一、Arrays類的概述和方法使用

A:Arrays類概述
	針對陣列進行操作的工具類。
	提供了排序，查詢等功能。
B:成員方法
	public static String toString(int[] a)
	public static void sort(int[] a)
	public static int binarySearch(int[] a,int key)
	static boolean equals(int[] a, int[] a2) 比較兩個陣列中的元素，是否一樣
    static int[] copyOf(int[] original, int newLength)  複製舊陣列中的元素到一個新的陣列中，新的陣列長度是newLength 從0開始複製舊陣列
    static int[] copyOfRange(int[] original, int from, int to) 複製舊陣列中的指定範圍間的幾個元素到新陣列中
C:案例演示	
​		通過Arrays類的功能來進排序和查詢

package org.westos.java16;

import java.util.Arrays;

/*A:Arrays類概述
        針對陣列進行操作的工具類。
        提供了排序，查詢等功能。
        B:成員方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
static boolean equals(int[] a, int[] a2) 比較兩個陣列中的元素，是否一樣
static int[] copyOf(int[] original, int newLength)  複製舊陣列中的元素到一個新的陣列中，新的陣列長度是newLength 從0開始複製舊陣列
static int[] copyOfRange(int[] original, int from, int to) 複製舊陣列中的指定範圍間的幾個元素到新陣列中
        C:案例演示
        ​		通過Arrays類的功能來進排序和查詢*/
public class Test {
    public static void main(String[] args) {
        int[] arr={1,5,2,6,8};
        System.out.println(Arrays.toString(arr));//[1,5,2,6,8] 將陣列返回這個形式的字串
        Arrays.sort(arr);//Quicksort 快速排序 從小到大排序陣列
        System.out.println(Arrays.toString(arr));//[1,2,5,6,8]
        int[] arr2={1,2,2,2,5,8,9,10};
        System.out.println(Arrays.binarySearch(arr2, 2));//二分查詢 陣列順序有序 找到的不一定是第一個出現元素的索引值   // 3
        System.out.println(Arrays.binarySearch(arr2, 2, 7, 10)); //索引含頭不含尾的範圍內查詢10   // -8 負數代表沒找到
        System.out.println(Arrays.equals(arr,arr2));//false
        int[] copy1 = Arrays.copyOf(arr, 10); //不足的長度用0補全
        int[] copy2 = Arrays.copyOfRange(arr, 2, 6); //索引含頭不含尾
        System.out.println(Arrays.toString(copy1));//[1, 2, 5, 6, 8, 0, 0, 0, 0, 0]
        System.out.println(Arrays.toString(copy2));//[5, 6, 8, 0]
        boolean[] arr3={true};
        boolean[] booleans = Arrays.copyOf(arr3, 5); //不足的長度用false補全
        System.out.println(Arrays.toString(booleans)); //[true, false, false, false, false]
        char[] arr4={'a'};
        String[] arr5={"a",""};
        System.out.println(Arrays.toString(Arrays.copyOf(arr4, 5))); //[a,  ,  ,  ,  ] //' ' 空格補全
        System.out.println(Arrays.toString(Arrays.copyOf(arr5, 5))); //[a, , null, null, null] //null補全
    }
}

二、Arrays類的原始碼解析

A:原始碼解析
	public static String toString(int[] a)
B:原始碼解析
	public static int binarySearch(int[] a,int key)

package org.westos.java16;

import java.util.Arrays;

/*A:原始碼解析
public static String toString(int[] a)
  B:原始碼解析
public static int binarySearch(int[] a,int key)*/
public class Test12 {
    public static void main(String[] args) {
        int[] arr={1,1,5,2};
        System.out.println(arrString(arr)); //[1,1,5,2]
        
        System.out.println(Arrays.toString(arr)); //[1, 1, 5, 2]
        System.out.println(Arrays.binarySearch(arr, 5)); //2
    }
    public static String arrString(int[] arr){
        if(arr==null){
            return null;
        }
        int max=arr.length-1;
        if(max==-1){
            return "[]";
        }
        StringBuffer stringBuffer = new StringBuffer("[");
        for (int i = 0; ; i++) {
            stringBuffer.append(arr[i]);
            if(i==max){
                return stringBuffer.append("]").toString();
            }
            stringBuffer.append(",");
        }
    }
    public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
}

三、基本型別包裝類的概述

A: 需求:
	a:將100轉換成二進位制 , 八進位制 , 十六進位制
	b:判斷一個數是否在int的範圍內
B:為什麼會有基本型別包裝類
	為了對基本資料型別進行更多的操作,更方便的操作,java就針對每一種基本資料型別提供了對應的類型別.
C:常用操作:	常用的操作之一：用於基本資料型別與字串之間的轉換。
D:基本型別和包裝類的對應
	byte 			Byte
	short			Short
	int			    Integer
	long			Long
	float			Float
	double		    Double
	char			Character
	boolean		    Boolean

四、Integer類的概述和構造方法

A:Integer類概述
	通過JDK提供的API，檢視Integer類的說明

	Integer 類在物件中包裝了一個基本型別 int 的值,
	該類提供了多個方法，能在 int 型別和 String 型別之間互相轉換，
	還提供了處理 int 型別時非常有用的其他一些常量和方法
B:構造方法
	public Integer(int value)
	public Integer(String s)  //要個一個字面上是數字的字串，如果不是就會報錯
C:案例演示
	使用構造方法建立物件

package org.westos.java16;
/*A:Integer類概述
        通過JDK提供的API，檢視Integer類的說明

        Integer 類在物件中包裝了一個基本型別 int 的值,
        該類提供了多個方法，能在 int 型別和 String 型別之間互相轉換，
        還提供了處理 int 型別時非常有用的其他一些常量和方法
        B:構造方法
public Integer(int value)
public Integer(String s)  //要個一個字面上是數字的字串，如果不是就會報錯
        C:案例演示
        使用構造方法建立物件*/
public class Test2 {
    public static void main(String[] args) {
        //Integer integer = new Integer(); //沒有提供無參構造方法，只提供了有參構造方法
        Integer integer = new Integer(5);
        int i = integer.intValue();
        System.out.println(i); //5
        Integer integer1 = new Integer('a');
        System.out.println(integer1); //97
/*        Integer integer2 = new Integer("a"); //NumberFormatException
        System.out.println(integer2);*/
        Integer integer2 = new Integer("123");
        System.out.println(integer2); //123
    }
}

五、String和int型別的相互轉換

A:int -- String
	a:和""進行拼接
	b:public static String valueOf(int i)
	c:int -- Integer -- String
	d:public static String toString(int i)
B:String -- int
	a:String -- Integer -- intValue();
	b:public static int parseInt(String s)
C:案例演示	
	String和int型別的相互轉換

package org.westos.java16;

import java.util.Arrays;

/*A:int -- String
        a:和""進行拼接
        b:public static String valueOf(int i)
        c:int -- Integer -- String
        d:public static String toString(int i)
  B:String -- int
        a:String -- Integer -- intValue();
        b:public static int parseInt(String s)
        C:案例演示
        String和int型別的相互轉換*/
public class Test3 {
    public static void main(String[] args) {
        int a=100;
        System.out.println(Integer.toBinaryString(a)); //public static String toBinaryString(int i)  返回型別是字串，轉換為2進位制
        System.out.println(Integer.toOctalString(a)); //public static String toOctalString(int i)  返回型別是字串，轉換為8進位制
        System.out.println(Integer.toHexString(a)); //public static String toHexString(int i)  返回型別是字串，轉換為16進位制
        System.out.println(Integer.MAX_VALUE); //public static final int   MAX_VALUE = 0x7fffffff; int型別範圍的最大值
        System.out.println(Integer.MIN_VALUE);//public static final int   MIN_VALUE = 0x80000000; int型別範圍的最小值
        System.out.println("=========================");
        String s="" + a; //第一種方式
        String s1 = String.valueOf(a); //第二種方式
        Integer integer = new Integer(a);
        String s2 = integer.toString(); //第三種方式
        System.out.println(Integer.toString(a)); //第四種方式
        System.out.println("=========================");
        String s3="123";
        System.out.println(Arrays.toString(s3.getBytes())); //[49, 50, 51]
        Integer integer1 = new Integer(s3);
        int i = integer1.intValue(); //第一種方式
        int i1 = Integer.parseInt(s3); //第二種方式
        System.out.println(i); //123
        System.out.println(i1); //123
    }
}

六、JDK5的新特性自動裝箱和拆箱

A:JDK5的新特性
	自動裝箱：把基本型別轉換為包裝類型別
	自動拆箱：把包裝類型別轉換為基本型別
B:案例演示
	JDK5的新特性自動裝箱和拆箱
	
	Integer ii = 100;
	ii += 200;
C:注意事項
	在使用時，Integer  x = null;程式碼就會出現NullPointerException。
	建議先判斷是否為null，然後再使用。

package org.westos.java16;

/*A:JDK5的新特性
        自動裝箱：把基本型別轉換為包裝類型別
        自動拆箱：把包裝類型別轉換為基本型別
        B:案例演示
        JDK5的新特性自動裝箱和拆箱

        Integer ii = 100;
        ii += 200;
        C:注意事項
        在使用時，Integer  x = null;程式碼就會出現NullPointerException。
        建議先判斷是否為null，然後再使用。*/
public class Test4 {
    public static void main(String[] args) {
        Integer a=123;//自動裝箱
       // Integer a = Integer.valueOf(123); //手動裝箱 valueOf(num)
        int b=a+123; //自動拆箱
        //int b=a.intValue()+123 //手動拆箱 intValue()
        System.out.println(b);//246
        Integer c=a+123; //經歷了自動拆箱和自動裝箱的過程
        //等價於下面兩步操作
/*        int i = a.intValue() + 123;  //手動拆箱
        Integer c = Integer.valueOf(i);//手動裝箱
*/
        Integer ii = 100; //自動裝箱
        ii += 200; //自動拆箱+自動裝箱
        System.out.println("=====================");
        Integer integer = Integer.valueOf("123");
        Integer integer1 = new Integer("123");
        Integer integer2 = Integer.valueOf(1); //自動裝箱
        Integer integer3 = new Integer(1);
    }
}

七、Integer的面試題

package org.westos.java16;

public class Test5 {
    public static void main(String[] args) {
/*        A:Integer的面試題
                看程式寫結果*/
                
//Integer這個類在繼承Object類中的equals()方法時,重寫了該方法
//比較的不再是地址值及引用是否相同,而是比較int這個基本型別數值是否相同

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2); //false
        System.out.println(i1.equals(i2)); //true  
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4); //false
        System.out.println(i3.equals(i4)); //true
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6); //false
        System.out.println(i5.equals(i6)); //true
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8); //ture
        System.out.println(i7.equals(i8)); //true
    }
}

package org.westos.java16;

public class Test6 {
    public static void main(String[] args) {
        Integer integer = Integer.valueOf(127);
        //自動裝箱 底層呼叫的是valueOf()來進行裝箱的
        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6); // false
        //自動裝箱
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);//true
        System.out.println(integer==i7); //true

        /*
         *   //當我們採用自動裝箱 Integer i7 = 127 這種方式 底層呼叫的是valueOf()來進行裝箱的
         *
         *   在 valueOf()方法裡面有這個判斷，當我們裝箱的值大於127 小於 -128 就會建立一個新的Integer物件返回。
         *
         * 如果說我們包裝的這個值   在 -128 <=值<=127 之間
         * 他會從 IntegerCache 這個內部類中的cache[] 陣列中取一個Integer物件返回給你
         *
         * IntegerCache 他已經提前幫你建立好了 256個Integer物件到這個cache[]中的。
         *
         *
         *
         * */

    }
}

package org.westos.java16;

//小結

public class Test7 {
    public static void main(String[] args) {
        Integer x=null;
/*        int a=x+1;
        System.out.println(a); //NullPointerException*/
        x=123; //相當於 x = Integer.valueOf(123);
/*        Integer xx = Integer.valueOf(123);
        System.out.println(x==xx); //true*/
        System.out.println(x.toString()); //重寫過 toString()方法
        System.out.println(x);
        Integer integer = new Integer(123);
        Integer integer1 = new Integer(123);
        Integer integer2 = Integer.valueOf(123);
        Integer integer3 = Integer.valueOf(123);
        System.out.println(integer==integer1);// false
        System.out.println(integer2==integer3);// true
        //採用valueOf()方法自動裝箱的原因是：-128 - 127 的數字裝箱的時候使用的都是同一個地址值物件，
        //而使用new Integer()裝箱時，每次都要new一個新的物件
        //所以valueOf()方法自動裝箱的時候更加節省記憶體空間
    }
}

相關文章