コレクション--list

プログラミング 2020-02-17 14:31:46 訪問数: null

1.なぜコレクションを使用

たとえば、次のデータ・ストレージ・
データを配列に格納することができる、配列ので、要素の位置の移動の大量を必要とする場合に長さを決定する際に、変更、削除、または要素を追加することができないだろう、前に重大な欠点を有しています。
アレイ：一つだけのデータ型を入れて、それが基本的なデータ型は、参照データタイプすることができことができます

本社は、問題を解くために使用することができます。

利点の組：高い除去要素の効率化
コレクションの特徴：コレクションは、複数のデータタイプを有することができる（一般的な使用ジェネリック、唯一つのデータタイプを格納する）が、彼は参照データ型を格納することができます

図2のセットの構造。

ここに画像を挿入説明

3.アプリケーションシナリオのセット

個々のニーズは時に一緒に同じ構造に統合されるようにすると、アカウントにセットを取ります。

4.ArrayList

  • 使用のArrayListの
public class Test {
    public static void main(String[] args) {
        Collection collection=new ArrayList();//接口new实现类
        System.out.println("集合是否为空:"+collection.isEmpty());
        //(1)添加元素
        collection.add("hello");
        collection.add(new Date());
        collection.add(123);
        collection.add("hello");
        collection.add(new Person("lisli",29, Gender.男));
        System.out.println("集合是否为空："+collection.isEmpty());
        System.out.println("集合中元素的个数:"+collection.size());
        System.out.println(collection);
        System.out.println(collection.remove("hello")); //将第一个hello删除
        //collection.clear();
        System.out.println(collection);
        System.out.println(collection.contains(123));
        Collection collection1=new ArrayList();
        collection1.add("world1");
        collection1.add("world2");
        collection1.add("world3");
        collection.addAll(collection1);
        System.out.println(collection);
        //遍历集合
        System.out.println("---------------------------------------");
        for(Object obj:collection){
            System.out.println(obj);//默认调用toString()方法
        }
        System.out.println("------------------自己使用迭代器遍历元素 hasNext() ,next()---------------------------");
        Iterator  ite= collection.iterator();
        while(ite.hasNext()){  //true就说明集合中有数据，为false，说明集合中没有数据，可以退出循环
           Object obj= ite.next();
            System.out.println(obj);
        }
    }
}
  • 基本構造のArrayList
    のArrayList：オブジェクト・タイプは、パッケージの配列である
    引数なしのコンストラクタは、ArrayListのを呼び出すようにするときのArrayListオブジェクト（1）を作成します
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //初始长度为0，在堆里开空间了
         transient Object[] elementData; //声明一个Object类型的数组,并没有new对象
        public ArrayList() {
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; //指向 是长度为0的那个数组
     }

（2）最初のコールアド（）メソッドは、要素を追加する10のObject型初期容量の配列に

private int size; //集合中元素的个数 ，默认值为0
      private static final int DEFAULT_CAPACITY = 10;
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //调用本类中的方法 
        elementData[size++] = e;
        return true;
    }
        
        private void ensureCapacityInternal(int minCapacity) {//minCapacity 的值为1
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
        
        private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//第一次调用add方法时执行
            return Math.max(DEFAULT_CAPACITY, minCapacity); //return Math.max(10,1);
        }
        return minCapacity;
    }
  private void ensureExplicitCapacity(int minCapacity) { //计算出来的最小容量为10
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0) //10-0>0?true 说明数组的长度已完全不够用
            grow(minCapacity);
    }
        
        private void grow(int minCapacity) {  //10
        // overflow-conscious code
        int oldCapacity = elementData.length;  //oldCapacity= 0
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //0+0 结果为 newCapacity=0
        if (newCapacity - minCapacity < 0)   //0-10<0 true
            newCapacity = minCapacity;          //newCapacity=10;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);   //数组拷贝
    }

第十一の呼び出しadd（）メソッドは、アレイ15の拡大（3）
; INT + newCapacity = oldCapacity（oldCapacity >> 1）
調査の欠失はArrayListの欠失アレイ型オブジェクトを変更して再検索変化する
のArrayListの利点を：インデックスクエリ高効率に応じて、ストレージスペースの保存
：ArrayListの欠点の削除、要素の数が多い、低効率を移動する必要性を追加し、内容に応じて一つ一つがメインの比較判断を見つけるため、非効率的

  • LinkedListの使用
public class Test2 {
    public static void main(String[] args) {
        Collection collection=new LinkedList();//接口new实现类
        System.out.println("集合是否为空:"+collection.isEmpty());
        //(1)添加元素
        collection.add("hello");
        collection.add(new Date());
        collection.add(123);
        collection.add("hello");
        collection.add(new Person("lisli",29, Gender.男));
        System.out.println("集合是否为空："+collection.isEmpty());
        System.out.println("集合中元素的个数:"+collection.size());
        System.out.println(collection);
        System.out.println(collection.remove("hello")); //将第一个hello删除
        //collection.clear();
        System.out.println(collection);
        System.out.println(collection.contains(123));
        Collection collection1=new LinkedList();
        collection1.add("world1");
        collection1.add("world2");
        collection1.add("world3");
        collection.addAll(collection1);
        System.out.println(collection);
        //遍历集合
        System.out.println("---------------------------------------");
        for(Object obj:collection){
            System.out.println(obj);//默认调用toString()方法
        }
        System.out.println("------------------自己使用迭代器遍历元素 hasNext() ,next()---------------------------");
        Iterator  ite= collection.iterator();
        while(ite.hasNext()){  //true就说明集合中有数据，为false，说明集合中没有数据，可以退出循环
           Object obj= ite.next();
            System.out.println(obj);
        }
    }
}
  • LinkedListの
    データ構造を根本的には、使用して、リンクリストLinkedListのある二重リンクリストを
transient Node<E> first;  //默认值均为null
 transient Node<E> last;
 
  public boolean add(E e) {
        linkLast(e);
        return true;
    }
        
        void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null); //当调用add方法时，new Node创建节点对象
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
        //LinkedList中的私有静态内部类
       private static class Node<E> {
        E item;  //当前要存储的元素
        Node<E> next;  //后继节点
        Node<E> prev;  //前驱节点
        Node(Node<E> prev, E element, Node<E> next) {  //创建一个节点对象
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

長所：削除、高効率を移動するための要素を追加します（ただし、要素に移動する必要がある）
短所：各要素ノード、次の要素を格納するためのアドレス空間の、具体的な増加を、より多くのスペースを取り、各ノードアドレスインデックスクエリに応じて、低効率をもたらす連続的、不規則、

  • 要素を追加、要素をイテレータオブジェクトを使用します
public class Test2 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("java");
        list.add("hello");
        list.add("world");
        list.add("sql");
        //想在遍历集合时添加元素
      // Iterator ite= list.iterator();
        ListIterator ite=list.listIterator();
       while(ite.hasNext()){
           Object obj=ite.next();
           if(obj.equals("hello")){
               ite.add("html");
           }
       }
        System.out.println(list);
    }
}

5.ジェネリック

作成するときに制限するオブジェクトのコレクションに格納されたデータ要素の種類のセット
使用される一般的なシンボル<データ型>
javacの前に：時間の一般的な機能

public class Test {
    public static void main(String[] args) {
    	//创建集合对象时，规则了集合中存储的元素的数据类型只能是String类型
      List<String> list=new ArrayList<String>();
      
      list.add("hello");
      list.add("java");
      list.add("world");
    //  list.add(123);
      
    }
}

一般的な分類

（1）汎用インタフェース

public interface Collection<E>{  //E代表一种数据类型，这个类型什么时候才能知道
}
 //在创建接口的实现类对象时，才能知道，在如下代码中，E所代表的数据类型是Integer
 Collection<Integer> coll=new ArrayList<Integer>();

（2）一般的なクラス

public class ArrayList<E>{  //E的数据类型什么时候知道，创建ArrayList对象时知道

}
  ArrayList<String> al=new ArrayList<String>();

（3）一般的な方法

public boolean add(E e) {}
  //E也代表一种数据类型 ,这个E的数据类型与ArrayList<E> 完全相同的，所以E的类型是在创建ArrayList的对象时确定

可変パラメータジェネリック方法：
（1）JDK1.5パラメータ変数である
（2）一般的なJDK1.5であります

public class Test {
    public static void main(String[] args) {
        Client<String> client=new Client<String>();//T的类型是String
        client.show("hello");
        //泛型方法，数据类型是在调用该方法时明确的，解决了同一个类中参数个数相同，类型不同的方法重载问题
        client.fun("hello");
        client.fun(123);
        client.fun(new Date());
         //可变参数的泛型方法，解决了数据类型不同，个数不同的方法重载问题
        client.method("hello");
        client.method("world1","world2","world3");
        client.method(123);
        client.method(8.7,9.8,7.6,9.9);
       //可变参数实际上就是一个数组
        Client<Integer> client2=new Client<Integer>();//T的类型时Integer
        client2.show(123);
    }
}
Penerx
公開された37元の記事 ・ ウォンの賞賛8 ・ ビュー2232
プライベートの手紙の 懸念

おすすめ

転載: blog.csdn.net/penerx/article/details/104356607
おすすめ
ライナスは「ドッグフードを食べる」ことに最も積極的！
Open Source Daily | Winamp プレーヤーがオープンソースになりつつある; 生成 AI の戦いは第 2 ラウンドにエスカレート; AI はバブルの初期段階に入った; Yongming を Alibaba Cloud に導入しますか?
ランキング
C言語プログラミングの最新の方法（第2回）第12章回答（自分で書いた回答、継続的に更新）
フレームワークの蜂のアップロードファイルに移動します
タイトルバーシリーズ：タイトルバーで遭遇したピットを非表示にする
Unityはゲームオブジェクトの様々な状況を取得します
N個の異なるボールは、Mどのように多くの種類のプログラムのと同じ袋に入れられますか？
オブジェクト指向のクラス、オブジェクト21
C ++オブジェクト指向プログラミングの研究ノート（8）
P3954 [NOIP2017 普及组] 成绩
分業のプロセス間通信 - ロック
ハッカーは通常、DOSコマンドウィンドウを使用します
アーカイブ
もっと
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(6)
2024-05-16(24)
2024-05-15(5)
2024-05-14(9)
2024-05-13(8)
2024-05-12(27)
2024-05-11(31)

コードワールド

© 2018 codetd.com