Java入门教程十二(集合与泛型)

在 Java 中数组的长度是不可修改的。然而在实际应用的很多情况下,无法确定数据数量。这些数据不适合使用数组来保存,这时候就需要使用集合。

Java 的集合就像一个容器,用来存储 Java 类的对象。有些容器内部存放的东西在容器内部是不可操作的,像水瓶里的水,除了将其装入和倒出之外,就不能再进行别的操作了,但是很容易装入和倒出;而有些容器内部存放的东西在容器内部是可以操作的,例如,衣柜里面摆放的衣服,不仅可以将衣服存放到衣柜中,还可以将衣服有序地摆放,以便在使用时快速查找,但是却不容易取出。Java 的集合类比这些容器功能还多,其中有些是方便放入和取出的,有些是方便查找的。在集合中经常会用到泛型来使集合更加安全。

集合

集合类都位于 java.util 包,其中提供了一个表示和操作对象集合的统一构架,包含大量集合接口,以及这些接口的实现类和操作它们的算法。一个集合是一个对象,但它表示一组对象,Java 集合中实际存放的是对象的引用值,不能存放基本数据类型值。

集合中的接口

集合框架是一个类库的集合,包含实现集合的接口。接口是集合的抽象数据类型,提供对集合中所表示的内容进行单独操作的可能。
Collection 接口:该接口是最基本的集合接口,一个 Collection 代表一个元素。
List 接口:该接口实现了 Collection 接口。List 是有序集合,允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置,用户能够使用索引(元素在 List 中的位置,类似于数组下标)来访问 List 中的元素,与数组类似。
Set 接口:该接口也实现了 Collection 接口。它不能包含重复的元素,SortedSet 是按升序排列的 Set 集合。
Map 接口:包含键值对,Map 不能包含重复的键。SortedMap 是一个按升序排列的 Map 集合。

接口实现类

Java 平台提供了许多数据集接口的实现类。例如实现 Set 接口的常用类有 HashSet 和 TreeSet,它们都可以容纳所有类型的对象,但是不能保证序列顺序永久不变

实现 List 接口的常用类有 ArrayList 和 LinkedList,它们也可以容纳所有类型的对象包括 null,并且都保证元素的存储位置。

实现 Map 映射的类是 HashMap,可实现一个键到值的映射。
HashSet:为优化査询速度而设计的 Set。它是基于 HashMap 实现的,HashSet 底层使用 HashMap 来保存所有元素,实现比较简单。
TreeSet:该类不仅实现了 Set 接口,还实现了 java.util.SortedSet 接口,该实现类是一个有序的 Set,这样就能从 Set 里面提取一个有序序列。
ArrayList:一个用数组实现的 List,能进行快速的随机访问,效率高而且实现了可变大小的数组。
LinkedList:对顺序访问进行了优化,但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法,能把它当成栈(Stack)或队列(Queue)来用。

Collection接口

Collection 接口是 List 接口和 Set 接口的父接口,通常情况下不被直接使用。Collection 接口定义了一些通用的方法,通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口,所以也可以调用这些方法

boolean add(E e)    向集合中添加一个元素,E 是元素的数据类型
boolean addAll(Collection c)    向集合中添加集合 c 中的所有元素
void clear()    删除集合中的所有元素
boolean contains(Object o)  判断集合中是否存在指定元素
boolean containsAll(Collection c)   判断集合中是否包含集合 c 中的所有元素
boolean isEmpty()   判断集合是否为空
Iterator<E>iterator()   返回一个 Iterator 对象,用于遍历集合中的元素
boolean remove(Object o)    从集合中删除一个指定元素
boolean removeAll(Collection c) 从集合中删除所有在集合 c 中出现的元素
boolean retainAll(Collection c) 仅仅保留集合中所有在集合 c 中出现的元素
int size()  返回集合中元素的个数
Object[] toArray()  返回包含此集合中所有元素的数组
public static void main(Strmg[] args)
{
    ArrayList list1=new ArrayList();    //创建集合 iist1
    ArrayList list2=new ArrayList();    //创建集合 Iist2
    list1.add("one");    //向 list1 添加一个元素
    list1.add("two");    //向 list1 添加一个元素
    list2.addAll(list1);    //将 list1 的所有元素添加到 list2
    list2.remove(0);   //删除第一个元素 
}

List集合

List 接口实现了 Collection 接口,它主要有两个实现类:ArrayList 类和 LinkedList 类。在 List 集合中允许出现重复元素。与 Set 集合不同的是,在 List 集合中的元素是有序的,可以根据索引位置来检索 List 集合中的元素,第一个添加到 List 集合中的元素的索引为 0,第二个为 1,依此类推

ArrayList 类

ArrayList 类提供了快速的基于索引的成员访问方式,对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合,允许对集合中的元素进行快速的随机访问

ArrayList():构造一个初始容量为 10 的空列表。
ArrayList(Collection<?extends E>c):构造一个包含指定 Collection 的元素的列表,这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。

ArrayList 类除了包含 Collection 接口中的所有方法之外,还包括 List 接口

E get(int index)    获取此集合中指定索引位置的元素,E 为集合中元素的数据类型
int index(Object o) 返回此集合中第一次出现指定元素的索引,如果此集合不包含该元
素,则返回 -1
int lastIndexOf(Obj ect o)  返回此集合中最后一次出现指定元素的索引,如果此集合不包含该
元素,则返回 -1
E set(int index, E element) 将此集合中指定索引位置的元素修改为 element 参数指定的对象。
此方法返回此集合中指定索引位置的原元素
List<E> subList(int fromlndex, int tolndex)返回一个新的集合,新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素,不包含 tolndex 索引处的元素
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");

list.get(0);//得到1

List sublist=new ArrayList();
sublist=list.subList(0,2); //subList 为1,2

LinkList类

LinkedList 类采用链表结构保存对象,这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时,使用 LinkedList 类比 ArrayList 类效果高
LinkedList 类除了包含 Connection 接口和 List 接口

void addFirst(E e)  将指定元素添加到此集合的开头
void addLast(E e)   将指定元素添加到此集合的末尾
E getFirst()    返回此集合的第一个元素
E getLast() 返回此集合的最后一个元素
E removeFirst() 删除此集合中的第一个元素
E removeLast()  删除此集合中的最后一个元素
LinkedList<String> products=new LinkedList<String>();    //创建集合对象
String product1=new String("product1");
String product2=new String("product2");

products.getFirst();//得到product1

Set集合

Set 集合也实现了 Collection 接口,它主要有两个实现类:HashSet 类和 TreeSet类。Set 集合中的对象不按特定的方式排序,只是简单地把对象加入集合,集合中不能包含重复的对象,并且最多只允许包含一个 null 元素

HashSet

HashSet 类是按照哈希算法来存储集合中的元素,使用哈希算法可以提高集合元素的存储速度,当向 Set 集合中添加一个元素时,HashSet 会调用该元素的 hashCode() 方法,获取其哈希码,然后根据这个哈希码计算出该元素在集合中的存储位置,

HashSet():构造一个新的空的 Set 集合。
HashSet(Collection<? extends E>c):构造一个包含指定 Collection 集合元素的新 Set 集合。其中,“< >”中的 extends 表示 HashSet 的父类,即指明该 Set 集合中存放的集合元素类型。c 表示其中的元素将被存放在此 Set 集合中。

HashSet hs=new HashSet();                     //调用无参的构造函数创建HashSet对象
HashSet<String> hss=new HashSet<String>();    //创建泛型的 HashSet 集合对象
String name=new String("HelloWorld");
String name1=new String("HelloWorld1");
hss(name); 
hss(name1); 

如果向 Set 集合中添加两个相同的元素,则后添加的会覆盖前面添加的元素,即在 Set 集合中不会出现相同的元素

TreeSet

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口,可以实现对集合升序排序。TreeSet 只能对实现了 Comparable 接口的类对象进行排序,因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小

包装类(BigDecimal、Biglnteger、 Byte、Double、
Float、Integer、Long 及 Short) 按数字大小比较
Character   按字符的 Unicode 值的数字大小比较
String  按字符串中字符的 Unicode 值的数字大小比较

TreeSet 类除了实现 Collection 接口的所有方法之外,还有以下方法

E first()   返回此集合中的第一个元素。其中,E 表示集合中元素的数据 类型
E last()    返回此集合中的最后一个元素
E poolFirst()   获取并移除此集合中的第一个元素
E poolLast()    获取并移除此集合中的最后一个元素
SortedSet<E> subSet(E fromElement,E toElement)  返回一个新的集合,新集合包含原集合中 fromElement 对象与 toElement
对象之间的所有对象。包含 fromElemen t对象,不包含 toElement 对象
SortedSet<E> headSet<E toElement〉   返回一个新的集合,新集合包含原集合中 toElement 对象之前的所有对象。
不包含 toElement 对象
SortedSet<E> tailSet(E fromElement) 返回一个新的集合,新集合包含原集合中 fromElement 对象之后的所有对
象。包含 fromElement 对象
TreeSet<Double> treeSet=new TreeSet<Double>(); 
treeSet.add(0.02);
treeSet.add(0.01);
treeSet.add(0.03);
for(int i=0;i<treeSet.toArray().length;i++)
{
     System.out.print(treeSet.toArray.toArray()[i]); //依次输出 0.01,0.02,0.03
}
SortedSet<Double> headTreeSet =scores.headSet(0.02); //headTreeSet内只有0.01

自然排序时只能向 TreeSet 集合中添加相同数据类型的对象,否则会抛出 ClassCastException 异常

Map集合

Map 是一种键-值对(key-value)集合,Map 集合中的每一个元素都包含一个键对象和一个值对象。其中,键对象不允许重复,而值对象可以重复,并且值对象还可以是 Map 类型的,Map 接口主要有两个实现类:HashMap 类和 TreeMap 类。其中,HashMap 类按哈希算法来存取键对象,而 TreeMap 类可以对键对象进行排序

Map 接口中提供的常用方法

V get(Object key)   返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value)   向 Map 集合中添加键-值对,返回 key 以前对应的 value,如果没有, 则返回 null
V remove(Object key)    从 Map 集合中删除 key 对应的键-值对,返回 key 对应的 value,如 果没有,则返回null
Set entrySet()  返回 Map 集合中所有键-值对的 Set 集合,此 Set 集合中元素的数据 类型为 Map.Entry
Set keySet()    返回 Map 集合中所有键对象的 Set 集合
Map map=new HashMap();
map.put("1","HelloWorld");
map.put("2","HelloWorld");

Collection类

Collections 类提供了许多操作集合的静态方法,借助这些静态方法可以实现集合元素的排序、填充和复制等操作

正向排序

sort() 方法主要有如下两种重载形式。

void sort(List list):根据元素的自然顺序对集合中的元素进行升序排序。
void sort(List list,Comparator comparator):按 comparator 参数指定的排序方式对集合中的元素进行排序。

List test=new ArrayList();
test.add(2);
test.add(1);
test.add(3);
Collections.sort(test); //此时数组为1,2,3

逆向排序

调用 reverse() 静态方法可以对指定集合元素进行逆向排序

void reverse(List list)    //对集合中的元素进行反转排序

List test=new ArrayList();
test.add(2);
test.add(1);
test.add(3);
Collections.reverse(test); //此时数组为3,2,1

复制

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中

void copy(List <? super T> dest,List<? extends T> src)

List srcList=new ArrayList();
destList.add("1");
destList.add("2");
List destList=new ArrayList();
Collections.copy(destList,srcList);//此时destList为1,2

填充

Collections 类的 fill() 静态方法可以对指定集合的所有元素进行填充操作

void fill(List<? super T> list,T obj)    //使用指定元素替换指定列表中的所有元素

List test=new ArrayList();
test.add("1");
test.add("2");
Collections.fill(srcList,"0"); //此时List里全是0

泛型

泛型可以在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高了代码的重用率。

泛型集合

泛型本质上是提供类型的“类型参数”,也就是参数化类型。我们可以为类、接口或方法指定一个类型参数,通过这个参数限制操作的数据类型,从而保证类型转换的绝对安全。

public class Person{
     private String name;
     public Person(String _name)
    {
        this.name=_name;
    }
}
Map<Integer, Person> persons=new HashMap<Integer, Person>();    //定义泛型 Map 集合
persons.add(new Person("HelloWorld"));

Map<Integer, Person> persons =new HashMap<Integer, Person>();”创建了一个键类型为 Integer、值类型为 Person 的泛型集合,即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Person 类型,否则编译出错。

Person preson = persons.get(0);//在获取 Map 集合中的元素时,不需要将"persons.get(id);"获取的值强制转换为 Person 类型,程序会隐式转换

泛型类

除了可以定义泛型集合之外,还可以直接限定泛型类的类型参数。

public class class_name<data_type1,data_type2,…>{}
//泛型类一般用于类中的属性类型不确定的情况下。
private data_type1 property_name1;

在实例化泛型类时,需要指明泛型类中的类型参数,并赋予泛型类属性相应类型的值

public class Person<T>{
    private T param;
    public T getParam(){
        return param;
   }
   public void setParam(T _param){
        this. param = _param;
   }
}
public class Employee{
    //类型体
}
public static void main(String[] args){
    //约束为整形
    Person<Integer> intergerPerson = new Person<Integer>();
    intergerPerson. setParam(1);
    //约束为字符串类型
    Person<String> intergerPerson1 = new Person<String>();
    intergerPerson1. setParam("String");
    //除基础类型外,也可以约束为自定义类型
    Person<Employee> intergerPerson2 = new Person<Employee>();
    intergerPerson1. setParam(new Employee());
}

泛型类中的类型参数可以有多个

public class Person<T,N,S>{
    //使用同上
}

泛型方法

泛型同样可以在类中包含参数化的方法,而方法所在的类可以是泛型类,也可以不是泛型类。
泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代类泛型化,那么就应该只使用泛型方法。另外,对一个 static 的方法而言,无法访问泛型类的类型参数。因此,如果 static 方法需要使用泛型能力,就必须使其成为泛型方法。

[访问权限修饰符][static][final]<类型参数列表>返回值类型方法名([形式参数列表])
public static<T> void Test(T t){
}
String helloWorld = "HelloWorld";
Test("HelloWorld");

 收藏 (0) 打赏

您可以选择一种方式赞助本站

支付宝赞助

微信钱包赞助

版权所有丨本站资源仅限于学习研究,严禁从事商业或者非法活动!:ABC资源站 » Java入门教程十二(集合与泛型)

切换注册

登录

忘记密码 ?

切换登录

注册