IO流

阿新 • • 發佈：2020-07-01

Java集合

一.集合的定義

是物件的容器，定義了對多個物件進行操作的常用方法，類似陣列功能
和陣列的區別：

陣列長度固定，集合長度不固定
陣列可以儲存基本型別和引用型別，集合只能儲存引用型別

二.Collection介面的方法

package oop;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
    public static void main(String[] args) {
        //建立集合
        Collection collection=new ArrayList();
        //新增元素
        collection.add("apple");
        collection.add("banana");
        collection.add("peach");
        System.out.println(collection.toString());
        //刪除元素
        collection.remove("apple");
        System.out.println(collection.size());
        //遍歷元素
        //1.增強for
        for (Object object:collection
             ) {
            System.out.println(object);
        }
        //2.使用迭代器（專門用來遍歷集合的一種方式）
        //hasNext():有沒有下一個元素；
        //next()：獲取下一個元素；
        //remove()：刪除當前元素
        Iterator it=collection.iterator();
        while(it.hasNext()){
            String s=(String)it.next();
            System.out.println(s);
            //在遍歷過程中不能使用collection的刪除方法，可以使用迭代器的刪除方法
            it.remove();
        }
        System.out.println(collection.size());
        //判斷元素是否存在
        System.out.println(collection.contains("apple"));
        System.out.println(collection.isEmpty());
    }
}

三.List介面使用

List介面的實現類有ArrayList，Vector，LinkedList

package oop;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
       List list=new ArrayList();
       //新增元素(自動裝箱)
        list.add("apple");
        list.add("banna");
        list.add(0,"pen");
        System.out.println(list.toString());
        //刪除
        list.remove(1);
        System.out.println(list.toString());
        //遍歷
        //1.使用for遍歷
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //2.使用增強for
        for(Object object:list){
            System.out.println(object);
        }
        //3.使用迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4.使用列表迭代器ListIterator，可以向前向後遍歷，新增，刪除，修改元素
        //從前往後遍歷
        ListIterator lit=list.listIterator();
        while(lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        //從後往前
        while(lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //判斷
        System.out.println(list.contains("pen"));
        System.out.println(list.isEmpty());
        //獲取位置
        System.out.println(list.indexOf("pen"));
        //subList;返回子集合，含頭不含尾
        List subList=list.subList(0,1);
        System.out.println(subList.toString());
    }
}

ArrayList


package oop;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        //建立集合
        ArrayList al=new ArrayList();
        //新增元素
        Student s1=new Student("zs",19);
        Student s2=new Student("ls",20);
        Student s3=new Student("ww",21);
        al.add(s1);
        al.add(s2);
        al.add(s3);
        //刪除元素
        al.remove(0);
        System.out.println(al.size());
        //遍歷元素
        // 使用迭代器
        Iterator it =al.iterator();
        while(it.hasNext()){
            Student s=(Student)it.next();//it.next()是Object型別，所以需要強轉換
            System.out.println(s);
        }
        ListIterator lt=al.listIterator();
        while(lt.hasNext()){
            System.out.println(lt.nextIndex()+":"+lt.next());
        }
        while(lt.hasPrevious()){
            System.out.println(lt.previousIndex()+":"+lt.previous());
        }


    }
}

ArrayList原始碼解析

預設容量大小：DEFAULT_CAPACITY = 10;如果沒有向集合中新增任何元素時，容量為0；新增一個元素之後，容量為10，每次擴容的大小為原來的1.5倍
存放元素的陣列：elementData;
實際元素的個數：size;

Vector

package oop;
import java.util.*;

public class Test {
    public static void main(String[] args) {
       //建立集合
        Vector vector= new Vector();
        //新增元素
        vector.add("apple");
        vector.add("bannana");
        vector.add("peach");
        //遍歷
        //使用列舉器
        Enumeration en=vector.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }

    }
}

LinkedList

連結串列結構實現，儲存結構是雙向連結串列

ArrayList:必須開闢連續空間，查詢快，增刪慢
LinkedList:無需開闢連續空間，查詢慢，增刪快

四.泛型

把型別作為引數來傳遞

泛型類

  package oop;
/**
 * 泛型類
 * 語法：類名<T,E,...>,T是型別佔位符，表示一種引用型別
 */
public class Test<T> {
    //使用泛型
    //建立變數,不能例項化
    T t;
    //作為方法的引數
    public void show(T t){
        System.out.println(t);
    }
    //泛型作為方法的返回值
    public T getT(){
        return t;
    }
}

呼叫

package oop;

public class Test2 {
    public static void main(String[] args) {
        Test<String> test=new Test<>();
        test.t="dengwenxiong";
        test.show("你剛好");
        String str=test.getT();
        System.out.println(str);
        Test<Integer> test1=new Test<>();
        test1.t=100;
        test1.show(101);
        int num1=test1.getT();
        System.out.println(num1);
    }
}

泛型介面

package oop;
/**
 *泛型介面
 * 語法：介面名<T>
 */
public interface test3<T> {
    String name="dengwenxiong";
    T server(T t);

}

泛型方法

package oop;

/**
 * 泛型方法
 * 語法：<T> 返回值型別
 */

public class Test{
    public <T> void show(T t){
        System.out.println("泛型方法"+t);
    }

}

泛型的好處

提高程式碼的重用性
防止型別轉換異常，提高程式碼的安全性

泛型集合

例：ArrayList al=new ArrayList();
那麼往集合裡新增資料就必須是String型別的，否則會報錯；

五.Set介面

無序，無下標，元素不可重複
Set介面的使用

package oop;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test{
    public static void main(String[] args) {

        Set<String> set=new HashSet<>();
        //新增資料
        set.add("peach");
        set.add("apple");
        set.add("bannaa");
        set.add("apple");//set不允許有重複元素
        System.out.println(set.toString());
        //遍歷
        //使用增強for,無法使用普通for迴圈，因為其沒有下標索引
        for(String string:set){
            System.out.println(string);
        }
        //使用迭代器Iterator
        Iterator<String> it =set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

    }

}

Set實現類

HashSet類

基於HashCode計算元素存放位置
當存入元素的雜湊碼相同時，會呼叫equals進行確認，若果結果為true，則拒絕後者存入，如為false則會以陣列+連結串列的方式存入

儲存過程：

根據hashcode計算儲存位置，如果此位置為空，則直接儲存。
否則，執行equals方法，如果equals方法為true，則認為是重複，否則形成連結串列。

package oop;
import java.util.HashSet;
public class Test{
    public static void main(String[] args) {
        HashSet<Student> hashSet=new HashSet<>();
        Student s1=new Student("deng",19);
        Student s2=new Student("wen",11);
        Student s3=new Student("xiong",12);
        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add(s3);
        hashSet.add(new Student("deng",19));//也能新增進去;重寫equals()方法可避免
        System.out.println(hashSet.toString());
        //
        hashSet.remove(new Student("deng",19));//重寫了equals方法後可刪除
        System.out.println(hashSet.toString());

    }

}

TreeSet

基於排列順序實現元素不重複；
實現SortedSet介面，對集合元素自動排序
元素物件的型別必須實現Comparable介面，指定排序規則
通過CompareTo方法確定是否為重複元素

package oop;
import java.util.TreeSet;
//其元素必須實現Comparable介面,compareTo()方法返回值為0，認為是重複元素
public class Test{
    public static void main(String[] args) {
        //建立集合
        TreeSet<Student> treeSet=new TreeSet<>();
        //新增元素
        Student s1=new Student("deng",11);
        Student s2=new Student("wen",12);
        Student s4=new Student("wen",15);
        Student s3=new Student("xiong",13);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        System.out.println(treeSet.toString());
        
    }

}

package oop;
public class Student implements Comparable {
    private String name;
    private int age;
    public Student(String name,int age){
       this.name=name;
       this.age=age;
    }

    @Override
    public String toString() {
        return "Student{" + "name="+name+" "+"age=" + age + '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Student) {
            Student p=(Student)o;
            int n1 = this.name.compareTo(p.name);
            int n2 = this.age - p.age;
            return n1 == 0 ? n2 : n1;
        }
        return 0;
    }
}

compartor介面，實現定製比較

'''java
package oop;
import java.util.Comparator;
import java.util.TreeSet;
//使用compartor元素可以不實現comparable介面
public class Test{
public static void main(String[] args) {
//建立集合,並指定規則
TreeSet treeSet=new TreeSet<>(new Comparator() {
@Override
public int compare(Student o1, Student o2) {
int n1=o1.getAge()-o2.getAge();
int n2=o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
//新增元素
Student s1=new Student("deng",11);
Student s2=new Student("wen",12);
Student s4=new Student("wen",15);
Student s3=new Student("xiong",13);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
System.out.println(treeSet.toString());

}
'''

使用comparator實現字串按長度排序

package oop;
import java.util.Comparator;
import java.util.TreeSet;
//使用compartor實現按字串的長度進行排序
public class Test{
    public static void main(String[] args) {
        TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length() - o2.length();
                int n2 =o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        treeSet.add("helloworld");
        treeSet.add("zhang");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("beijing");
        treeSet.add("xian");
        treeSet.add("nanjing");
        System.out.println(treeSet.toString());
    }
}

六.Map集合

Map介面特點：

用於儲存任意鍵值對
鍵：無序，無下標，不允許重複（唯一）
值：無序，無下標，允許重複

package oop;
import java.util.*;
//map介面使用
public class Test{
    public static void main(String[] args) {
        //建立集合
        Map<String,String> map=new HashMap<>();
        //新增元素
        map.put("cn","中國");
        map.put("usa","美國");
        map.put("us","英國");
        System.out.println(map.toString());
        //刪除
        map.remove("us");
        System.out.println(map.toString());
        //遍歷
        //使用keySet()--返回的是一個key的set集合;
        Set<String> set=map.keySet();
        for(String str:set){
            System.out.println(str+":"+map.get(str));
        }
        //使用entrySet進行遍歷，返回一個Entry物件(鍵值對)的set集合
        for(Map.Entry<String,String> entries:map.entrySet()){
            System.out.println(entries.getKey()+":"+entries.getValue());
        }
        //判斷
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("中國"));
    }

}

Map的實現類

HashMap

package oop;
import java.util.*;
//HashMap的使用；儲存結構:雜湊表（陣列+連結串列+紅黑樹）;使用key的hashcode和equals判斷重複
public class Test{
    public static void main(String[] args) {
        HashMap<Student,String> student=new HashMap<>();
        Student s1=new Student("deng",12);
        Student s2=new Student("wen",13);
        Student s3=new Student("xiong",14);
        student.put(s1,"beijing");
        student.put(s2,"tianmen");
        student.put(s3,"hangzhou");
        System.out.println(student.toString());
     }
}

當陣列長度大於64，連結串列長度大於8試，會從連結串列轉換成紅黑樹進行儲存；當連結串列長度小於6時，會變為連結串列儲存。執行緒不安全，執行效率快；允許null作為key或value；

TreeMap

實現了SortedMap介面(是Map的子介面)，可以對key自動排序

package oop;
import java.util.*;
//TreeMap的使用；儲存結構:紅黑樹；
public class Test{
    public static void main(String[] args) {
        //定製比較，或者Student類必須實現Comparable介面
        TreeMap<Student,String> treeMap=new TreeMap<>(new Comparator<Student>(){
            @Override
            public int compare(Student o1, Student o2) {
                int n1=o1.getAge()-o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Student s1=new Student("deng",11);
        Student s2=new Student("wen",12);
        Student s3=new Student("xiong",13);
        treeMap.put(s1,"上海");
        treeMap.put(s2,"北京");
        treeMap.put(s3,"湖北");
        System.out.println(treeMap.toString());
     }
}

七.Collection工具類

package oop;
import java.util.*;
public class Test{
    public static void main(String[] args) {
      List<Integer> lt=new ArrayList<>();
        lt.add(10);
        lt.add(340);
        lt.add(101);
        lt.add(1054);
        lt.add(102);
        lt.add(1089);
        System.out.println(lt.toString());
        //排序sort()
        Collections.sort(lt);
        System.out.println(lt);
        //搜尋binarySearch()
        int i=Collections.binarySearch(lt,340);
        System.out.println(i);
        //複製copy()
        List<Integer> cplt=new ArrayList<>();
        for(int j=0;j<lt.size();j++){
            cplt.add(0);
        }
        Collections.copy(cplt,lt);
        System.out.println(cplt);
        //反轉reverse()
        Collections.reverse(lt);
        System.out.println(lt);
        //打亂shuffle()
        Collections.shuffle(lt);
        System.out.println(lt);
        //list轉成陣列
        Integer[] arr=lt.toArray(new Integer[0]);
        System.out.println(Arrays.toString(arr));
        //將陣列轉成list,受限list，無法新增和刪除；
        String[] names={"zhangshan","lisi","wangwu"};
        List<String> list2=Arrays.asList(names);
        System.out.println(list2);
    }
}

IO流