2020/3/26學習筆記-day27

java-day27

目錄

java-day27

實例

1、常規實現

2、用內部類實現

包裝類型

3、基本類型和包裝類型之間的自動裝箱和拆箱（jdk1.5以後）

4、Integer類的靜態內部類IntegerCache[緩存機制]

5、一些容易出錯的地方

== 和 equals方法的區別

==

equals

實例

---

實例

1、常規實現

package com.zzb.day27;
​
​
//迭代器接口
public interface Iterator{
    
    boolean hasNext();
    String next();
    
}
​
class StringIterator implements Iterator{
    
    //要和一個倉庫捆綁起來，還要知道迭代器訪問的位置
    private Repository rep;
    
    private int index = -1;
    
    public StringIterator(Repository rep){
        this.rep = rep;
    }
    
    public boolean hasNext(){
        index++;
        if(index<rep.size()){
            return true;
        }else
            return false;
    }
    
    //獲取當前索引數據
    public String next(){
        return rep.get(index);
    }
}

package com.zzb.day27;
​
import java.util.Arrays;
​
//倉庫類型
public interface Repository{
    
    //往倉庫中添加數據
    void add(String data);
    
    //返回當前倉庫中已經存放了多少數據
    int size();
    
    //返回針對當前倉庫的迭代器
    //這個迭代器可以幫我們從倉庫中取出一個個數據
    Iterator getIterator();
    
    String get(int index);
}
​
class StringRepository implements Repository{
    //數組，用來保存數據
    private String[] db;
    //當前倉庫存放數據的數量
    private int size;
    
    //當前類中，初始化數組使用的默認長度 
    private static final int DEFAULT_ARRAY_LENGTH = 5;
    
    public StringRepository(){
        db = new String[DEFAULT_ARRAY_LENGTH];
    }
    
    public void add(String data){
        //倉庫容量已滿，要進行擴展
        if(size==maxLength()){
            System.out.println("當前倉庫已滿，不能再存數據");
            db = Arrays.copyOf(db,maxLength()*2);
        }
        db[size++] = data;
    }
    
    public int size(){
        return this.size;
    }
    
    public Iterator getIterator(){
        return new StringIterator(this);
    }
    
    private int maxLength(){
        return db.length;
    }
    
    public String get(int index){
        return db[index];
    }
}

2、用內部類實現

package com.zzb.day27;
​
//迭代器接口
public interface Iterator{  
    boolean hasNext();
    String next();
}

package com.zzb.day27;
​
import java.util.Arrays;
​
import java.util.Arrays;
​
//倉庫類型
public interface Repository{
​
    //往倉庫中添加數據
    void add(String data);
​
    //返回當前倉庫中已經存放了多少數據
    int size();
​
    //返回針對當前倉庫的迭代器
    //這個迭代器可以幫我們從倉庫中取出一個個數據
    Iterator getIterator();
}
​
class StringRepository implements Repository{
    //數組，用來保存數據
    private String[] db;
    //當前倉庫存放數據的數量
    private int size;
​
    //當前類中，初始化數組使用的默認長度 
    private static final int DEFAULT_ARRAY_LENGTH = 5;
​
    public StringRepository(){
        db = new String[DEFAULT_ARRAY_LENGTH];
    }
​
    public void add(String data){
        //倉庫容量已滿，要進行擴展
        if(size==maxLength()){
            System.out.println("當前倉庫已滿，要擴展");
            db = Arrays.copyOf(db,maxLength()*2);
        }
        db[size++] = data;
    }
​
    public int size(){
        return this.size;
    }
​
    public Iterator getIterator(){
        return new It();
    }
​
    private int maxLength(){
        return db.length;
    }
​
    private class It implements Iterator{
​
        private int index = -1;
​
        public boolean hasNext(){
            index++;
​
            if(index<size){
                return true;
            }
            else return false;
        }
​
        //獲取當前索引數據
        public String next(){
            return db[index];
        }
    }
}
​

測試類

package com.zzb.day27;
​
//一個倉庫類型
//一個迭代器類型
public class RepositoryTest{
    public static void main(String[] args){
        Repository rep = new StringRepository();
        
        rep.add("hello1");
        rep.add("hello2");
        rep.add("hello3");
        rep.add("hello4");
        rep.add("hello5");
        rep.add("hello6");
        rep.add("hello7");
        rep.add("hello8");
        rep.add("hello9");
        
        int size = rep.size();
        System.out.println("size = "+size);
    
        Iterator it = rep.getIterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
        
    }
}
​

 

 

包裝類型

在java中， 有八種基本的數據類型，這八種基本類型只能表示一些最簡單的數字，這些數字最小的在內存中佔8位，最大佔64位。這些都是簡單的數字，不是對象，所以也不能用來調用方法或者屬性。

在java的API中，對這八種基本類型，又專門提供了類類型，目的就是爲了分別把這八種基本類型的數據，包裝成對應的類類型，這時候就變成對象了，就可以調用方法了或者訪問屬性了。

基本類型	包裝類型
boolean	Boolean
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

1、這些包裝類型都在java.lang下

可以直接使用不需要導入

2、這些包裝類型都定義了相關屬性和方法

包裝類的使用

public class WrapperClass{
    public static void main(String [] args){
        WrapperClass q = new WrapperClass();
        q.test1();
    }
​
    public void test1(){
        int i = 10;
        Integer o = new Integer(i);
        System.out.println(o.toString(o));
        System.out.println(o.toString(o,2));
        System.out.println(o.toString(o,8));
        System.out.println(o.toString(o,16));
    }
}

 

 

3、基本類型和包裝類型之間的自動裝箱和拆箱（jdk1.5以後）

老版本

//int-----> Integer
Integer i = new Integer(1);
​
//Integer----->int
int j = i.intValue();

新版本

//int-----> Integer
Integer o = 1;
System.out.println(o);
​
//Integer----->int
int i= o;
System.out.println(i);

4、Integer類的靜態內部類IntegerCache[緩存機制]

這靜態內部類的作用是幫Integer類，把一些常用的數字所包裝成的對象給緩存起來。[-128,127]

private static class IntegerCache{
​
    static final int low = -128;
    static final int high;
    static final Integer[] cache;
    static  {
        int i = 127;
        String str = VM.getSavedProperty
            ("java.lang.Integer.IntegerCache.high");
        if (str != null) {
            try {
                int j = Integer.parseInt(str);
                j = Math.max(j, 127);
                i = Math.min(j, 2147483518);
            } catch (NumberFormatException numberFormatException) {}
        }
​
        high = i;
        cache = new Integer[high - -128 + 1];
        byte b = -128;
        for (byte b1 = 0; b1 < cache.length; b1++) {
            cache[b1] = new Integer(b++);
        }
        assert high >= 127;
    }
}

public static Integer valueOf(int paramInt) {
    if (paramInt >= -128 && paramInt <= IntegerCache.high)
        return IntegerCache.cache[paramInt + 128]; 
    return new Integer(paramInt);
}

5、一些容易出錯的地方

pub1ic void test1(int i){}
public void test2(Integer i){}
public void test3(long i){}
public void test4(Long i){}
main :
t. test1(1);//編譯通過int i = 1; 正常賦值
t.test2(1);//編譯通過Integer i = 1; 自動裝箱
t.test3(1);//編譯通過1ong i = 1; 隱式類型轉換
​
t. test4(1);//編譯報錯Long i = 1; int和Long之間沒有任何關係
​
t.test4(1L)//編譯通過  自動裝箱
​

 

== 和 equals方法的區別

==

能用在基本類型數據之間，也可以用作引用類型的對象之間

如果是倆個基本類型數字相比， == 比較是基本類型的倆個數值是否相等 如果是倆個引用類型的變量相比，==比較是倆個引用所指向對象的內存地址值是否相等 另外，==是java中的基本的操作符，我們無法改變==號的默認的比較方式。

equals

只能用在倆個引用類型的對象之間，這個方法是0bject中定義的，所以對象直接或間接繼承object 類之後，都可以使用這個繼承過來的equals方法。

在0bject中，equals方 法默認實現是這樣的:

public boolean equals(bject obj) {
    return (this == obj);
}

那麼就是意味着，如果調用的equlas方法是從父類0bject中繼承過來的(沒有重寫)，那麼這比較也是藉助於==來比較倆個引用所指向的對象的內存地址值是否相等。

如果我們想通過自己的方法重新定義兩個對象相等值的判斷，我們在子類中可以重寫equals方法。

實例

編寫一個學生類，有id、name、age屬性，創建倆個學生對象比較，它們是否相等，使用==號進行比較，使用從父類Object繼承過來方法equals比較，使用自己重寫後的equals進行比較。分別觀察幾種方式比較後的結果有什麼不同。

public class Test{
​
    public static void main(String[] args){
        Student s1 = new Student(001L,"zs",12);
        Student s2 = new Student(001L,"zs",12);
        System.out.println(s1.equals(s2));
    }
}
​
class Student{
    private long id;
    private String name;
    private int age;
    public Student(){
    }
    public Student(long id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public boolean equals(Student s){
        return  (this.id == s.id)&&
                this.name.equals(s.name)&&
                (this.age == s.age);
    }
}