Java基础知识笔记(八:集合类)

目录

1   style=”font-family: 金鼎文;”>集合类简介 

2  List style=”font-family: 石籀文;”>介绍与简单用 

2.1  LinkedList style=”font-family: 黑体;”>介绍与简便用 

2.2  ArrayList style=”font-family: 甲骨文;”>介绍与简单用 

2.3  Vector style=”font-family: 草书;”>介绍与简便以

2.3.1
 Stack介绍与简单用 

3  Set style=”font-family: 宋体;”>介绍 

3.1 HashSet style=”font-family: 石籀文;”>介绍和简便用 

3.2 TreeSet style=”font-family: 黑体;”>介绍和简便用 

3.3 Linked HashSet style=”font-family: 宋体;”>介绍 

4  Map style=”font-family: 金鼎文;”>介绍和简便用 

4.1 Hashtable style=”font-family: 仿宋;”>介绍及简便以 

4.2 HashMap style=”font-family: 金鼎文;”>简单以 

4.3 WeakHashMap style=”font-family: 宋体;”>介绍 

 

 


1  集合类简介

集合类存放于java.util包被。

集合类存放的且是目标的援,而未对象自我,出于表明上之利,大家遂集合中的对象就是是借助集中目的的援(reference)。

会合类型紧要出3栽:list(集)、set(列表)和map(映射)。

切切实实涉及如下:

Collection
List
├LinkedList
├ArrayList
└Vector
 └Stack

Set

├HashSet
├TreeSet
└Linked HashSet

Map
├Hashtable
├HashMap
└WeakHashMap

    Collection是绝基本的相会接口,一个Collection代表同样组Object,即Collection的元素(Elements)。一些Collection允许发生同一的因素如任何一些很。一些可以排序而其他一部分挺。Java SDK不提供直接接轨自Collection的好像,Java SDK提供的好像都是累自Collection的“子接口”如List和Set。
 
所有实现Collection接口的近乎都须提供简单单正经的构造函数:无参数的构造函数用于创立一个空的Collection,有一个 Collection参数的构造函数用于创建一个初的Collection,这一个新的Collection与传播的Collection有一致的要素。后一个构造函数允许用户复制一个Collection。
 
咋样尽历Collection中的各类一个素?不论Collection的实在类型如何,它还襄助一个iterator()的章程,该办法重临一个迭代子,使用该迭代子即可逐一走访Collection中每一个素。典型的用法如下:
    Iterator it =
collection.iterator(); // 拿到一个迭代子
    while(it.hasNext()) {
      Object obj = it.next(); //
拿到下一个要素
    }

 

 

 


2  List介绍和简单利用

介绍:List是平稳的Collection,使用是接口可以准确的决定每个元素插入的职。用户会用索引(元素于List中的岗位,类似于数组下标)来走访List中之因素,这仿佛于Java的数组。和下部要提到的Set不同,List允许暴发相同之素。
  除了有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,再次回到一个 ListIterator接口,和规范的Iterator接口相比较,ListIterator多矣有add()之类的方,允许添加,删除,设定元素,
还会上或者朝向后遍历。
  实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

实例:寻找
List 中的顶酷无比小值

以下实例演示了什么用
Collections类的 max() 和 min() 方法来博取List中最好老最小值:

import java.util.*;
public class Main {
   public static void main(String[] args) {
      List list = Arrays.asList("one Two three Four five six one three Four".split(" "));
      System.out.println(list);
      System.out.println("最大值: " + Collections.max(list));
      System.out.println("最小值: " + Collections.min(list));
   }}

上述代码运行输出结果吧:

[one, Two, three, Four, five, six, one, three, Four]
最大值: three
最小值: Four

2.1  LinkedList介绍及简便以

介绍:LinkedList类是双向列表,列表中的每个节点都富含了针对前一个和后一个因素的引用.
LinkedList的构造函数如下

  1. public LinkedList():  ——生成空的链表
  2. public LinkedList(Collection col):
     复制构造函数
    实例:落链表的首个及结尾一个因素

    import java.util.LinkedList;  
      
    public class LinkedListTest{  
      public static void main(String[] args) {  
         LinkedList lList = new LinkedList();  
        lList.add(“1”);  
         lList.add(“2”);  
         lList.add(“3”);  
        lList.add(“4”);  
         lList.add(“5”);  
      
      
        System.out.println(“链表的首先只因素是 : ” + lList.getFirst());  
         System.out.println(“链表最终一个素是 : ” + lList.getLast());  
       }  
    }  

2.2  ArrayList介绍和简便利用

介绍:ArrayList就是传说被的动态数组,换种说法,就是Array的繁杂版本,它提供了之类一些好处: 
动态的增多和缩短元素 
实现了ICollection和IList接口 
活的装置数组的高低

 实例:

ArrayList List = new ArrayList(); 
for( int i=0;i <10;i++ ) //给数组增加10个Int元素 
List.Add(i); 
//..程序做一些处理 
List.RemoveAt(5);//将第6个元素移除 
for( int i=0;i <3;i++ ) //再增加3个元素 
List.Add(i+20); 
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

2.3  Vector介绍和简单利用

介绍:

Vector类实现了一个动态数组。和ArrayList和一般,不过互相是见仁见智的:

Vector是并访问的。

Vector包含了不少风俗习惯的点子,这一个艺术无属集合框架。

Vector首要用超越行未明了数组的高低,或者只是用一个可改大小的数组的意况。

Vector类协助4种植构造方法。

率先栽构造方法成立一个默认的往量,默认大小也10:

Vector()

老二栽构造方法创设指定大小的向量。

Vector(int size)

老三栽构造方法创造指定大小的向量,并且增量用incr指定. 增量表示向量每趟增的元素数目。

Vector(int size,int incr)

季受构造方法创造一个饱含集合c元素的向量:

Vector(Collection c)

实例:

import java.util.*;
public class VectorDemo {

   public static void main(String args[]) {
      // initial size is 3, increment is 2
      Vector v = new Vector(3, 2);
      System.out.println("Initial size: " + v.size());
      System.out.println("Initial capacity: " +
      v.capacity());
      v.addElement(new Integer(1));
      v.addElement(new Integer(2));
      v.addElement(new Integer(3));
      v.addElement(new Integer(4));
      System.out.println("Capacity after four additions: " +
          v.capacity());

      v.addElement(new Double(5.45));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Double(6.08));
      v.addElement(new Integer(7));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Float(9.4));
      v.addElement(new Integer(10));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Integer(11));
      v.addElement(new Integer(12));
      System.out.println("First element: " +
         (Integer)v.firstElement());
      System.out.println("Last element: " +
         (Integer)v.lastElement());
      if(v.contains(new Integer(3)))
         System.out.println("Vector contains 3.");
      // enumerate the elements in the vector.
      Enumeration vEnum = v.elements();
      System.out.println("\nElements in vector:");
      while(vEnum.hasMoreElements())
         System.out.print(vEnum.nextElement() + " ");
      System.out.println();
   }}

以上实例编译运行结果如下:

Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1Last element: 12Vector contains 3.
Elements in vector:1 2 3 4 5.45 6.08 7 9.4 10 11 12

2.3.1  Stack介绍和简单利用

介绍:

栈是Vector的一个子类,它实现了一个正规的后进先出的库。 

库只定义了默认构造函数,用来成立一个空栈。
堆栈除了包括由Vector定义之拥有术,也定义了温馨之一些道。

Stack()

除去由于Vector定义的具备术,自己为定义了有的办法:

序号

方法描述

1

boolean empty() 
测试堆栈是否为空。

2

Object peek( )
查看堆栈顶部的对象,但不从堆栈中移除它。

3

Object pop( )
移除堆栈顶部的对象,并作为此函数的值返回该对象。

4

Object push(Object element)
把项压入堆栈顶部。

5

int search(Object element)
返回对象在堆栈中的位置,以 1 为基数。

 

实例:

下的次表明这集合所帮助的几乎种办法

import java.util.*;
public class StackDemo {

   static void showpush(Stack st, int a) {
      st.push(new Integer(a));
      System.out.println("push(" + a + ")");
      System.out.println("stack: " + st);
   }

   static void showpop(Stack st) {
      System.out.print("pop -> ");
      Integer a = (Integer) st.pop();
      System.out.println(a);
      System.out.println("stack: " + st);
   }

   public static void main(String args[]) {
      Stack st = new Stack();
      System.out.println("stack: " + st);
      showpush(st, 42);
      showpush(st, 66);
      showpush(st, 99);
      showpop(st);
      showpop(st);
      showpop(st);
      try {
         showpop(st);
      } catch (EmptyStackException e) {
         System.out.println("empty stack");
      }
   }}

以上实例编译运行结果如下:

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

 

 


3  Set介绍

介绍: 

    Set不保留重复的因素。Set中最日常叫应用的是测试归属性,你可好爱的询问有对象是否在有Set中。Set具有与Collection完全等同的接口,由此并未任何附加的功用。实际上Set就是Collection,只是作为不同。

 
实现了Set接口的基本点出HashSet、TreeSet、LinkedHashSet这几乎单共同点就是是每个相同之宗就保留一份。他们吧来不同点,区别如下:

3.1 HashSet介绍与简单以

介绍:

 HashSet用的是十分复杂的章程来囤积元素的,使用HashSet可以太抢之拿走集合中的因素,效能非凡高(以空间更换时间)。会遵照hashcode和equals来庞端是否是与一个对象,假如hashcode一样,并且equals再次来到true,则是暨一个靶,不可知再存放。

实例:

package com.set;

import java.util.HashSet;
import java.util.Set;

class Student{
    int id;
    public Student(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student){
            Student  stu = (Student) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
}
public class HashSetTest {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<Student>();
        Student s1 = new Student(1);
        Student s2 = new Student(1);
        Student s3 = new Student(2);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        for (Student s : set) {
            System.out.println(s);
        }
    }
}

恰恰而上例所示,重写了hashCode()和equals()方法来分同意对象后,就不能存和为目的了。如果注释这简单独格局,则兼具Student对象就是不同对象,都好存放。

3.2 TreeSet介绍与简便用

介绍:

 TreeSet为无克存放重复对象,不过TreeSet会自行排序,假使存放的对象无法排序虽会报错,所以存放的目的要指定排序规则。排序规则包括自排序和客户排序。

  ①本排序:TreeSet要上加哪个目的就是在谁目的类方面实现java.lang.Comparable接口,并且又写comparaTo()方法,重返0则代表是暨一个靶,否则也不同对象。

      ②客户排序:建立一个叔方类并实现java.util.Comparator接口。并更写方法。定义集合式也TreeSet ts = new TreeSet(new 第三方类());

实例:

上边一个例证用TreeSet存放自然排序的对象:

package com.set;

import java.util.Set;
import java.util.TreeSet;

class Student1 implements Comparable<Student1>{
    int id;
    public Student1(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student1){
            Student1  stu = (Student1) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
    public int compareTo(Student1 o) {
        return (this.id-o.id);
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        Set<Student1> set = new TreeSet<Student1>();
        Student1 s1 = new Student1(5);
        Student1 s2 = new Student1(1);
        Student1 s3 = new Student1(2);
        Student1 s4 = new Student1(4);
        Student1 s5 = new Student1(3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        for (Student1 s : set) {
            System.out.println(s);
        }
    }

}

 输出结果吧:

1
2
3
4
5

3.3 Linked HashSet介绍

介绍:LinkedHashSet依照插入顺序保存对象,同时还保存了HashSet的询问速度。

 

 

 


4  Map介绍和简便用

介绍:

Map接口中键和值一一映射. 可以经过键来得到值。

给一定一个键以及一个价,你得用该值存储在一个Map对象. 之后,你可经键来访问对应之价值。

当访问的价值不存在的时节,方法就会师遗弃来一个NoSuchElementException很是.

当对象的类型以及Map里元素类型不般配的时,就相会抛弃来一个
ClassCastException卓殊。

当在不允许利用Null对象的Map中使用Null对象,会丢弃来一个NullPointerException 至极。 

当尝试修改一个只是念之Map时,会扔来一个UnsupportedOperationException非凡。

序号

方法描述

1

void clear( )
 从此映射中移除所有映射关系(可选操作)。

2

boolean containsKey(Object k)
如果此映射包含指定键的映射关系,则返回 true。

3

boolean containsValue(Object v)
如果此映射将一个或多个键映射到指定值,则返回 true。

4

Set entrySet( )
返回此映射中包含的映射关系的 Set 视图。

5

boolean equals(Object obj)
比较指定的对象与此映射是否相等。

6

Object get(Object k)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。

7

int hashCode( )
返回此映射的哈希码值。

8

boolean isEmpty( )
如果此映射未包含键-值映射关系,则返回 true。

9

Set keySet( )
返回此映射中包含的键的 Set 视图。

10

Object put(Object k, Object v)
将指定的值与此映射中的指定键关联(可选操作)。

11

void putAll(Map m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。

12

Object remove(Object k)
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。

13

int size( )
返回此映射中的键-值映射关系数。

14

Collection values( )
返回此映射中包含的值的 Collection 视图。

 

 实例: 

import java.util.*;
public class CollectionsDemo {

   public static void main(String[] args) {
      Map m1 = new HashMap(); 
      m1.put("Zara", "8");
      m1.put("Mahnaz", "31");
      m1.put("Ayan", "12");
      m1.put("Daisy", "14");
      System.out.println();
      System.out.println(" Map Elements");
      System.out.print("\t" + m1);
   }}

上述实例编译运行结果如下:

Map Elements
        {Mahnaz=31, Ayan=12, Daisy=14, Zara=8}

4.1 Hashtable介绍及简单以

介绍:

Hashtable是固有之java.util的等同有些, 是一个Dictionary具体的贯彻 。

可是,Java 2 重构的Hashtable实现了Map接口,由此,Hashtable现在合龙及了聚众框架中。它和HashMap类很相像,不过她补助并。

比如说HashMap一样,Hashtable在哈希表中存储键/值对。当以一个哈希表,要指定用作键的对象,以及要链接到该键的价。

下一场,该键经过哈希处理,所取的散列码被看作存储在该表中值的目录。

实例:

下边的程序表明是数据结构匡助之七只艺术:

import java.util.*;
public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();
      Enumeration names;
      String str;
      double bal;

      balance.put("Zara", new Double(3434.34));
      balance.put("Mahnaz", new Double(123.22));
      balance.put("Ayan", new Double(1378.00));
      balance.put("Daisy", new Double(99.22));
      balance.put("Qadir", new Double(-19.08));

      // Show all balances in hash table.
      names = balance.keys();
      while(names.hasMoreElements()) {
         str = (String) names.nextElement();
         System.out.println(str + ": " +
         balance.get(str));
      }
      System.out.println();
      // Deposit 1,000 into Zara's account
      bal = ((Double)balance.get("Zara")).doubleValue();
      balance.put("Zara", new Double(bal+1000));
      System.out.println("Zara's new balance: " +
      balance.get("Zara"));
   }}

如上实例编译运行结果如下:

Qadir: -19.08Zara: 3434.34Mahnaz: 123.22Daisy: 99.22Ayan: 1378.0
Zara's new balance: 4434.34

4.2 HashMap简单利用

介绍:以下实例演示了什么运用 Collection
类的 iterator() 方法来遍历集合:

import java.util.*;
public class Main {
   public static void main(String[] args) {
      HashMap< String, String> hMap = 
      new HashMap< String, String>();
      hMap.put("1", "1st");
      hMap.put("2", "2nd");
      hMap.put("3", "3rd");
      Collection cl = hMap.values();
      Iterator itr = cl.iterator();
      while (itr.hasNext()) {
         System.out.println(itr.next());
     }
   }}

如上代码运行输出结果为:

3rd
2nd
1st

4.3 WeakHashMap介绍

介绍:

  WeakHashMap落实了Map接口,是HashMap的同样种植实现,他使用弱引用作为中数据的储存方案,WeakHashMap可以作为简单缓存表的解决方案,当系统内存不够的当儿,垃圾收集器会自动的散没有以其余任何地方给引用的键值对。

 
 如果急需由此相同布置很死的HashMap作为缓存表,那么得考虑采取WeakHashMap,当键值不有的时刻增长到表中,存在即取出其值。

WeakHashMap weakMap = new WeakHashMap<Integer, byte[]>();

for(int i = 0; i < 10000; i++){

Integer ii = new Integer(i);

weakMap.put(ii, new byte[i]);

}

 

参考资料:

      1、Java Vector

       2、Java 实例 –
HashMap遍历

       3、Java Hashtable
接口

       4、Java Map
接口

       5、Java Stack

     
 6、Java集合类详解

     
 7、java笔记四:Set接口

 

相关文章