JAVA常用集合框架用法详解基础篇一之Colletion接口
Posted 追风少年lulei
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA常用集合框架用法详解基础篇一之Colletion接口相关的知识，希望对你有一定的参考价值。
首先，在学习集合之前我们能够使用的可以存储多个元素的容器就是数组。
下面举几个例子主要是引出集合类的：
1、8,4,5,6,7,55,7,8 像这样的类型相同的可以使用数组来存储，本例可以用int[] arr来存储。
2、”zhnagsan”,true,68 像这样的可以使用StringBuilder或者StringBuffer来存储，但最终需要使用.toString()的方法转换成字符串才可以使用。即 变为：”zhnagsantrue68”。
3、”李四”,25 像这样的可以使用对象来存储，如: new Person(“李四”,25);
一、为什么要使用集合呢，那什么时候需要使用集合类呢？？？？？？
1.集合类的由来：
对象用来封装特有的数据，对象多了需要存储，或者对象的个数不确定，就使用集合容器进行存储。原来集合是用来存储个数不确定的对象的。这一点是数组做不到的。
2.集合的特点：
--是用于存储对象的容器；
--集合的长度是可变的；
--集合中不可以存储基本的数据类型（如:int、 char、 boolean之类的），一般我们可以将基本数据类型进行装箱处理，然后在存储在集合中。
接下来用一幅图表示集合的整体框架：
3、集合容器因内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。
我们先详细的说说框架的顶层Collection接口：
Collection的常见方法：
---添加。
boolean add(Object obj); //添加一个对象
boolean addAll(Collection coll);//添加一个集合
</pre><pre name="code" class="html">代码如下：
package com.ll.list;
import java.util.ArrayList;
import java.util.List;
public class testAdd {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> allList=new ArrayList<String>();//定义List对象
List<String> list=new ArrayList<String>();//定义另一个List对象
allList.add("hello");//使用从Collection接口中继承的方法
allList.add(0, "world");//此方法为List自己扩展的方法
System.out.println(allList);
list.add("LL");
list.add("www.ll.com");
allList.addAll(list);//增加一组对象，此方法是从父类继承的
System.out.println(allList);
allList.addAll(1, list);//在指定的位置上，进行增加一组对象。此方法是List接口自己扩展的方法
System.out.println(allList);
}
}
---删除
boolean remove(Object obj);
boolean removeAll(Collection coll);
void clear();//将集合中的元素清空
package com.ll.list;
import java.util.ArrayList;
import java.util.List;
public class testRemove {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> allList=new ArrayList<String>();//实例化一个List对象
allList.add("kello");
allList.add("joke");
allList.add("www.ll.com");
allList.add("world");
System.out.println(allList);//输出List对象中的元素
allList.remove(0);//删除指定位置的内容
System.out.println(allList);
allList.remove("joke");//删除指定的内容
System.out.println(allList);
}
}
---判断
boolean contains(Object obj);//是否包含
boolean containsAll(Collection coll);
boolean isEmpty();//判断集合中是否含有元素package com.ll.list;
import java.util.ArrayList;
import java.util.List;
public class testSizeAndGet {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> allList=new ArrayList<String>();//定义并实例化List对象
allList.add("world");
allList.add("world");
allList.add("kkorld");
allList.add("pprld");
allList.add("lllrld");
allList.add("wqwld");
System.out.println("从前向后输出：");
for(int i=0;i<allList.size();i++){
System.out.println(allList.get(i)+"..");
}
System.out.println("从后向前输出：");
for(int i=allList.size()-1;i>=0;i--){
System.out.println(allList.get(i)+"..");
}
}
}---获取
int size();//获取集合中元素的个数
Iterator iterator();//取出元素的方式，使用的是迭代器
Object get(int i);代码如下：
package com.ll.list;
import java.util.ArrayList;
import java.util.List;
public class testSizeAndGet {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> allList=new ArrayList<String>();//定义并实例化List对象
allList.add("world");
allList.add("world");
allList.add("kkorld");
allList.add("pprld");
allList.add("lllrld");
allList.add("wqwld");
System.out.println("从前向后输出：");
for(int i=0;i<allList.size();i++){
System.out.println(allList.get(i)+"..");
}
System.out.println("从后向前输出：");
for(int i=allList.size()-1;i>=0;i--){
System.out.println(allList.get(i)+"..");
}
}
}我们再来测试一下迭代器Iterator的用法。
代码如下：
package com.ll.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* 迭代输出：Iterator
* 是最常用的的集合输出操作
* 但是只能进行单向的从前向后输出
*/
public class testIterator {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> allList=new ArrayList<String>();
allList.add("hello");
allList.add("world");
allList.add("__ll__");
//直接实例化一个Iterator接口
System.out.println("删除前的集合"+allList.toString());
Iterator<String> it=allList.iterator();
while(it.hasNext()){//判断是否还有元素
String str=it.next();
if("__ll__".equals(str)){
it.remove();//使用remove方法删除指定的元素
}
else{
System.out.print(str+"、");//next()方法用来取出当前元素
}
}
System.out.println("\\n删除后的集合"+allList.toString());
}
}----其他
boolean retainAll(Collection coll);//取与coll集合的交集
Object[] toArray();将集合转成对象数组<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>4、Collection是接口，所以只能通过子类来实例化。如：Collection coll=new ArrayList();
注意：这里会稍微提一下之前的迭代输出的代码。迭代输出有两种写法，如下：
法一：
Iterator it=coll.iterator();
while(it.hasnext){
system.out.println(it.next());
}
法二：
for(Iterator it=coll.iterator;it.hasnext();){
system.out.println(it.next());
}
比较两种方法，我们会注意到while()循环结束后，it会一直占着内存不放，而for循环不会出现这种情况。
5、迭代器的原理
迭代器，取出元素的对象，该对象必须依赖具体的容器。因为每一个容器的数据结构是不同的。所以该迭代器是在容器中进行内部的实现。对于使用容器而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可。也就是iterator方法。Iterator接口就是对所有Collection容器进行元素取出的公共接口。
补充：接下来补充一个Collection.Sort()方法的实例：可以看看代码：
//collection.sort()方法的测试类，这个类还需要Students类和一个自定义比较器//Studentscomparator类
package com.wq.list;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import javax.swing.text.html.ListView;
/**
* 将要完成
* 1.通过Collections.sort(),对Integer泛型的List集合进行排序
* @author LULEI
*
*/
public class CollectionsTest {
/**
* 通过Collections.sort(),对Integer泛型的List集合进行排序
* 使用Random类来生成不相等的随机数10个
*/
public void testListSort1(){
List<Integer> integer=new ArrayList<Integer>();
Random random=new Random(); //产生一个随机种子对象
int k=0;
//生成10个随机数
for(int i=0;i<10;i++){
do{
k=random.nextInt(100);//生成100以内的一个随机数
}while(integer.contains(k));//判断随机数是否重复，如果不重复就跳出while循环
integer.add(k); //向list集合中添加元素
System.out.println(k+"已经成功添加");
}
System.out.println("-----排序前------");
for(Integer it:integer){
System.out.println("元素："+it);
}
//调用sort()方法来进行排序
Collections.sort(integer); //直接调用父方法的sort()进行排序
System.out.println("--------排序后--------");
for(Integer it:integer){
System.out.println("元素："+it);
}
}
/**
* 通过Collections.sort(),对String泛型的List集合进行排序
* 向List集合中添加3个字符串
*/
public void testListSort2()
{
List<String> str=new ArrayList<String>();
str.add("microsoft");
str.add("baidu");
str.add("google");
System.out.println("----排序前----");
for(String ss:str){
System.out.println(ss);
}
Collections.sort(str);
System.out.println("----排序后----");
for(String ss:str){
System.out.println(ss);
}
}
/**
* 通过Collections.sort(),对String泛型的List集合进行排序
* 向List里添加十条随机字符串
* 字符串的长度要不大于10
* 每个字符串的每个字符都是随机生成的，但可以重复
* 每个字符串是不可以重复的
* @param args
*/
public void testListOfString(){
List<String> newStr=new ArrayList<String>();//用于存储字符串的
Random randomLength=new Random();//随机生成字符串的长度
//所有字符查询表
String table="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
//生成10个字符串
for(int i=0;i<10;i++){
StringBuilder sb=new StringBuilder();//用来存储随机产生的字符串
do{
//确定当前字符串的长度
int length=randomLength.nextInt(11);//注意每个字符串不能大于10个字符
while(length==0){//避免length的值为0，否则这样就会产生空字符串
length=randomLength.nextInt(11);
}
for(int m=0;m<length;m++){
int pos=randomLength.nextInt(table.length());//获取字符查询表中任意一个随机的位置
sb.append(table.charAt(pos));//将该位置上的字符添加到sb中
}
}while(newStr.contains(sb.toString()));//判断是否有重复的字符串，如果集合中不含有该字符串则退出while循环
newStr.add(sb.toString());//使用toString方法转化为String类型
}
System.out.println("====排序前=====");
for(String stBd:newStr){
System.out.println(stBd);
}
//调用sort()方法进行排序
Collections.sort(newStr);
System.out.println("====排序后=====");
for(String stBd2:newStr){
System.out.println(stBd2);
}
Collections.sort(newStr);
}
/**
* 如何给Students类型的List集合元素进行排序
* 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
* 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
* this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
* @param args
*/
public void testStudentsList(){
List<Students> liStu=new ArrayList<Students>();//实例化一个集合，用来存储Students对象
Random random=new Random();//生成随机种子用于随机生成几个不相等的id号
//添加3个Students的对象
liStu.add(new Students(Integer.toString(random.nextInt(1000)), "tim"));
liStu.add(new Students(Integer.toString(random.nextInt(1000)), "jack"));
liStu.add(new Students(Integer.toString(random.nextInt(1000)), "lucy"));
liStu.add(new Students(Integer.toString(100000), "lily"));
/*
* 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
* 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
* this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
*/
System.out.println("=====排序前====");
for(Students stu:liStu){
System.out.println(stu.getId()+"."+stu.getName());
}
Collections.sort(liStu);
System.out.println("=====排序后====");
for(Students stu:liStu){
System.out.println(stu.getId()+"."+stu.getName());
}
/**
* 接下来是用comparator接口来确定新的临时比较规则：使用姓名来排序
* 过程如下：1、定义一个StudentComparator类，然后
* 让这个类继承comparator接口，然后覆写该接口的compare()方法
* 2、然后调用Collections.sort()方法来进行排序
*/
Collections.sort(liStu,new StudentsComparator());
System.out.println("-------按照名字进行排序---------");
System.out.println("=====排序后====");
for(Students stu:liStu){
System.out.println(stu.getId()+"."+stu.getName());
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
CollectionsTest ct=new CollectionsTest();
//排序Integer类型的List
ct.testListSort1();
//排序String类型的List
// ct.testListSort2();
//排序随机生成的String类型的List
ct.testListOfString();
//排序Students类
ct.testStudentsList();
}
}
//Students类
package com.wq.list;
import java.util.HashSet;
import java.util.Set;
/**
* 学生类
* @author LULEI
*
*/
public class Students implements Comparable<Students>{
private String name;
private String id;
public Set<Courses> courses;//用于后面添加课程
public Students(String id,String name){
this.setId(id);
this.setName(name);
//Set是一个接口，不能直接实例化，通过HashSet()对courses进行实例化
this.courses=new HashSet<Courses>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Students))
return false;
Students other = (Students) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public int compareTo(Students o) {
// TODO Auto-generated method stub
//将比较规则设置为id号
return this.id.compareTo(o.id);
}
}
//StudentsComparator类
package com.wq.list;
import java.util.Comparator;
public class StudentsComparator implements Comparator<Students> {
@Override
public int compare(Students o1, Students o2) {
// TODO Auto-generated method stub
//将规则改成比较名字
return o1.getName().compareTo(o2.getName());
}
}运行结果如下：
57已经成功添加
22已经成功添加
65已经成功添加
52已经成功添加
27已经成功添加
90已经成功添加
38已经成功添加
77已经成功添加
47已经成功添加
21已经成功添加
-----排序前------
元素：57
元素：22
元素：65
元素：52
元素：27
元素：90
元素：38
元素：77
元素：47
元素：21
--------排序后--------
元素：21
元素：22
元素：27
元素：38
元素：47
元素：52
元素：57
元素：65
元素：77
元素：90
====排序前=====
Zj
gkjvUfLB
WgPiL3VX
Xj2DtAtL9
kyrkT9ILYa
G
s0FfBD
bZR
eDA
pVihS
====排序后=====
G
WgPiL3VX
Xj2DtAtL9
Zj
bZR
eDA
gkjvUfLB
kyrkT9ILYa
pVihS
s0FfBD
=====排序前====
319.tim
606.jack
464.lucy
100000.lily
=====排序后====
100000.lily
319.tim
464.lucy
606.jack
-------按照名字进行排序---------
=====排序后====
606.jack
100000.lily
464.lucy
319.tim这一篇先写到这，下一篇我将说说Collection的子类。
以上是关于JAVA常用集合框架用法详解基础篇一之Colletion接口的主要内容，如果未能解决你的问题，请参考以下文章