Java学習ノート(集合_2)

12049 ワード

16セット
16.3汎用
モデルを導入する前に、Javaタイプは元のタイプ、複雑なタイプに分けられ、複雑なタイプは配列とクラスに分けられます.モデルを導入すると、複雑なタイプをより多くのタイプに細分化することができます.例えば、従来のタイプのリストは、現在、リスト、リストなどより多くのタイプに細分化されている.
フォーマット:<>で操作する参照データ型を定義しますが、<>はタイプを受信するために使用されます.
汎用クラス定義の汎用:クラス全体で有効であり、メソッドで使用される場合、汎用オブジェクトが操作する特定のタイプを明確にすると、操作するすべてのタイプが固定されます.
静的メソッドはクラスで定義された汎用型にアクセスできません.静的メソッド操作の適用データ型が不確定である場合、汎用型をメソッドに定義できます.
汎用定義メソッドの場合<>は修飾子の後に置かれ、値タイプの前に戻ります.例1:

public class GenericDemo {
    public static void main(String[] args) {
        Demo<Integer> d = new Demo<Integer>();

        d.show(new Integer(2));
        d.print(9);

        Demo<String> s = new Demo<String>();

        s.show("ssa");
        s.print("asfdaf");

        Demo.method("gabriel");
    }
}

class  Demo<T>{
    public void show(T t){
        System.out.println("show:"+t);
    }
    public<Q> void print(Q q){
        System.out.println("print:"+q);
    }
    public static<W> void method(W w){
        System.out.println("method:"+w);
    }
}

実行結果:
例2:

public class GenericDemo {
    public static void main(String[] args) {
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(3);
    }
}
interface Inter<T>{
    void show(T t);
}

class InterImpl<T> implements Inter<T>{
    public void show(T t){
        System.out.println(t);
    }
}

実行結果:3
ワイルドカード?プレースホルダとしても理解できます.
16.4 Mapインタフェース
データ間にマッピング関係がある場合はmapセットを使用します.
一般的な方法:

value put(key,value):nullが返されていない場合、keyに関連付けられた前の値を返します.

void clear()を削除:mapセットを空にします.value remove(Object key):指定したkeyに基づいてこのキー値ペアを削除します.

boolean containsKey(key);boolean containsValue(value); boolean isEmpty();

value get(key):キーによって値を取得し、キーがなければnullを返します.もちろんnullを返すことで、指定キーが含まれているかどうかを判断することができます.int size():キー値ペア数を取得します.

Mapには次のものが含まれます.

Hashtable:下位層はハッシュテーブルデータ構造であり、nullキーnull値を格納することはできない.この集合はスレッド同期である、jdk 1.0、効率が低い;

HashMap:下位層はハッシュテーブルデータ構造であり、null値とnullキーを使用することができる.このセットは非同期である.jdk 1.2、効率が高い.

TreeMap:最下位はツリーデータ構造で、スレッドは同期していません.Mapコレクション内のキーのソートに使用できます.例1:

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapDemo {

    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        //    ，                ，      
        System.out.println(map.put("1", "Gabriel1"));
        System.out.println(map.put("1", "Gabriel6"));
        map.put("2", "Gabriel2");
        map.put("3", "Gabriel3");

        System.out.println("containsKey:"+map.containsKey("1"));
        System.out.println("get:"+map.get("3"));
        System.out.println("remove:"+map.remove("1"));
        System.out.println(map);

        Collection<String> col = map.values();
        System.out.println(col);
    }
}

運転結果:

Mapコレクションの取り出し方法:1.map集合をset集合(keySet()メソッド)に変換し、例2のように反復器で取り出す.2.entrySet():map集合のマッピング関係をset集合に格納し、この関係のデータ型がMapである.例3のようにEntry.
例2:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("2", "Gabriel2");
        map.put("3", "Gabriel3");
        map.put("1", "Gabriel1");
        map.put("4", "Gabriel4");

        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while(it.hasNext()){
            String key = it.next();
            //     map   get         
            String value = map.get(key);
            System.out.println("key:"+key+"+value:"+value);
        }
    }
}

実行結果:
例3:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("2", "Gabriel2");
        map.put("3", "Gabriel3");
        map.put("1", "Gabriel1");
        map.put("4", "Gabriel4");

        Set<Map.Entry<String,String>> entrySet = map.entrySet();

        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<String,String> me = it.next();
            System.out.println(me.getKey()+".."+me.getValue());
        }
    }
}

実行結果:
例4:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {

    public static void main(String[] args) {
        HashMap<Student1,String> hm = new HashMap<Student1,String>();
        hm.put(new Student1("Gabriel1",21), "  ");
        hm.put(new Student1("Gabriel1",21), "  ");
        hm.put(new Student1("Gabriel2",22), "  ");
        hm.put(new Student1("Gabriel3",23), "  ");
        hm.put(new Student1("Gabriel4",24), "  ");
        System.out.println("/*****       ：********/");
        Set<Student1> keySet = hm.keySet();
        Iterator<Student1> it = keySet.iterator();
        while(it.hasNext()){
            Student1 stu = it.next();
            String address = hm.get(stu);
            System.out.println(stu+"..."+address);
        }
        System.out.println("/******       ：*******/");
        Set<Map.Entry<Student1, String>> entrySet= hm.entrySet();
        Iterator<Map.Entry<Student1, String>> it1 = entrySet.iterator();
        while(it1.hasNext()){
            Map.Entry<Student1, String> me = it1.next();
            System.out.println(me.getKey()+"..."+me.getValue());
        }
    }

}
class Student1 implements Comparable<Student1>{

    private String name;
    private int age;
    Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String toString(){
        return name+":"+age;
    }
    //  hashCode  
    public int hashCode() {
        return name.hashCode()+age;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student1 other = (Student1) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    public int compareTo(Student1 s) {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if(num == 0)
            return this.name.compareTo(s.name);
        return num;
    }
}

実行結果:
hashCode()メソッドを書き換える方法については、次を参照してください.http://blog.csdn.net/liushuai_ly/article/details/8197508
16.5 Arraysツールクラス
Arrays:集合フレームワークのツールクラスで、いずれも静的です.
16.5.1配列変化集合
ArraysのasList(配列)は,例5のように配列を集合に変換する.
例5:

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
        String[] arr = {"abc","cc","xyz"};

        List<String> list = Arrays.asList(arr);
        boolean b = list.contains("ac");
        System.out.println(b);
    }
}

実行結果:false
P.S.配列の長さは固定されているため、結合した添削方法では使用できません.そうしないと、UnsupportedOperationExceptionが発生します.
配列内の要素がすべてオブジェクトである場合、集合になると、配列内の要素は直接集合内の要素に変わります.配列内の要素が基本データ型である場合、例6のように配列は集合内の要素として存在する.
例6:

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
        String[] arr = {"abc","cc","xyz"};

        List<String> list = Arrays.asList(arr);
        /*boolean b = list.contains("ac");
        System.out.println(b);*/

        Integer[] nums = {1,3,2};
        List<Integer> li = Arrays.asList(nums);
        System.out.println(li);
    }
}

運転結果:[1,3,2]
16.5.2集合変数配列
CollectionインタフェースのtoArrayメソッド.

指定されたタイプの配列の長さが集合のsizeより小さい場合、このメソッドの内部には新しい配列が作成され、長さは集合のsizeである.

指定したタイプの配列の長さがセットのsizeより大きい場合、新しい配列は作成されず、渡された配列を使用するので、適切な配列を作成するのが最適です.

集合変配列は要素の操作を制限するためであり,削除する必要はない.
例7:

import java.util.ArrayList;
import java.util.Arrays;

public class CollectionToArray {

    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String> ();

        al.add("a1");
        al.add("a2");
        al.add("a3");

        String[] arr = al.toArray(new String[6]);

        System.out.println(Arrays.toString(arr));
    }
}

運転結果:[a 1,a 2,a 3,null,null,null]
高度なforループ:for(データ型変数名:遍歴されたコレクション(Collection)または配列){}
コレクションを巡回し、コレクション要素のみを取得でき、コレクションを操作できません.反復器
例8:

import java.util.ArrayList;

public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();

        arr.add("a1");
        arr.add("a2");
        arr.add("a3");

        for(String s : arr){
            s = "c";
            System.out.println(s);
        }
        System.out.println(arr);
    }
}

実行結果:
例9:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();

        arr.add("a1");
        arr.add("a2");
        arr.add("a3");

        for(String s : arr){
            s = "c";
            System.out.println(s);
        }
        System.out.println(arr);

        int[] al = {1,3,4};
        for(int i :al){
            System.out.println("i:"+i);
        }

        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1, "a");
        hm.put(2, "b");
        hm.put(3, "c");
        Set<Integer> keySet = hm.keySet();
        for(Integer i : keySet){
            System.out.println(i+"::"+hm.get(i));
        }

        for(Map.Entry<Integer, String> me:  hm.entrySet()){
            System.out.println(me.getKey()+"---"+me.getValue());
        }   
    }
}

実行結果:
メソッドの可変パラメータ:使用時に、可変パラメータは必ずパラメータリストの一番後ろに定義することに注意してください.
例10:

public class ParamMethodDemo {

    public static void main(String[] args) {
        show("a",1,2,3,4);
        show("c",1,2,3,4,5);
    }
    public static void show(String a,int... arr){
        System.out.print(arr.length+a);
    }
}

実行結果:45 ac
≪静的インポート｜Static Import｜oem_src≫:インポートされたクラス内のすべての静的メンバー.

import java.util.*;
import static java.util.Arrays.*;//  Arrays           
public class StaticImportDemo {

    public static void main(String[] args) {
        int[] arr = {4,3,5};
        Arrays.sort(arr);
        int index =binarySearch(arr, 1);
        System.out.println(Arrays.toString(arr));//      ，         ；
        //      ，             。
        System.out.println("Index:"+index);
    }
}

実行結果:

Pythonにおけるselfの解釈

[linux] x86_64スレッドスタックがどのように割り当てられているか