一．Java集合：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
集合特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
二．基本的集合：
1.Collection：是有单列数据组成的集合
Collection|——Set：元素是无序，元素不可以重复。
|——HashSet: 哈希表（依赖hashCode()和equals()）
|——TreeSet: 红黑树（排序：自然排序（comparable）和比较器（comparator））
|——List:元素是有序的，元素可以重复。因为该集合体系有索引。
|——ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|——LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|——Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
2.Map：是由键值对组成的集合,Map的键(key)是唯一的,值(value)可以重复。
Map|——HashMap :是基于哈希表的Map接口实现。哈希表的作用是用来保证键的唯一性的。线程不安全，效率高。允许null键和值。
|——LinkedHashMap：是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序
由哈希表保证键的唯一性由链表保证键盘的有序（
|——TreeMap :键是红黑树结构，可以保证键的排序和唯一性
|——Hashtable:线程安全，效率低。不允许null键和值。
三．Collection
1.Vector：枚举就是Vector特有的取出方式,发现枚举和迭代器很像,其实枚举和迭代是一样的。
<span style="font-size:14px;">import java.util.Enumeration;
import java.util.Vector;
class VectorDemo{
public static void main(String[]args){
Vector v = new Vector();
v.add("java1");
v.add("java2");
v.add("java3");
Enumeration enumeration = v.elements(); //枚举
while(enumeration.hasMoreElements()){
System.out.println(enumeration.nextElement()); }
}
}
</span>2.LinkedList:
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 First in Firstout FIFO如同一个水管。
/*
LinkedList:特有方法：
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst(); //在此列表的开头插入指定的元素。
offerLast(); //在此列表末尾插入指定的元素。
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
*/
<span style="font-size:14px;">class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
//sop(link);
// sop(link.getFirst());
// sop(link.getFirst());
//sop(link.getLast());
//sop(link.removeFirst());
//sop(link.removeFirst());
//sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
</span>3.ArrayList
class CollectionDemo
{
public static void main(String[] args)
{
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
/*
Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
while(it.hasNext())
{
sop(it.next());
}
*/
for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
}
//保存两个集合的交集
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");
//al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。
al1.removeAll(al2);
sop("al1:"+al1);
sop("al2:"+al2);
}
//常用的添加、删除、判断、获取的方法
public static void base_method()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
//打印原集合。
sop("原集合:"+al);
//3，删除元素。
//al.remove("java02");
//al.clear();//清空集合。
//4，判断元素。
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空？"+al.isEmpty());
//2，获取个数。集合长度。
sop("size:"+al.size());
//打印改变后的集合。
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
4.TreeSet
例子1（compareTo排序）：
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
记住，排序时，当主要条件相同时，一定判断一下次要条件。
*/
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi007",20));
//ts.add(new Student("lisi01",40));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
/**/
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
例子2（comparator比较器）：
/*
练习：按照字符串长度排序。
字符串本身具备比较性。但是它的比较方式不是所需要的。
这时就只能使用比较器。
*/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator()); //将比较器对象传到容器
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
/*
if(s1.length()>s2.length())
return 1;
if(s1.length()==s2.length())
return 0;
*/
//按照字符串长度排序
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
5.HashSet
保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
例子1:
<span style="font-size:14px;">import java.util.*;
/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
class HashSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
// hs.add(new Person("a2",12));
// hs.add(new Person("a4",14));
//sop("a1:"+hs.contains(new Person("a2",12)));
// hs.remove(new Person("a4",13));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()
{
return name.hashCode()+age*37;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person)) //判断对象是不是person类的对象
return false;
Person p = (Person)obj; //强制转换成Person对象
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
</span>四．Map
1.Hashtable：Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
Properties能用于保存配置，限制程序的运行次数。
import java.io.*;
import java.util.*;
/**
保存Properties 配置文件
*/
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//method_1();
loadDemo();
}
public static void loadDemo()throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");
//将流中的数据加载进集合。
prop.load(fis);
prop.setProperty("wangwu","39");
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos,"haha");
// System.out.println(prop);
prop.list(System.out);
fos.close();
fis.close();
}
2.TreeMap：
排序方法： |-- Comparable（Map实现此接口）的int compareTo（object obj）
|--Comparator（传入Map的带参构造的形式参数）的int compare(object obj1,object obj2) //可用泛型定义comparator
获取键值的常用方法：调用entrySet()、keySet()、values()，然后利用set迭代器和Map方法获取。
/* 需求：对学生对象的年龄进行升序排序。 因为数据是以键值对形式存在的。 所以要使用可以排序的Map集合。TreeMap。 */ import java.util.*; class StuNameComparator implements Comparator<Student> //用泛型定义comparator接口 { public int compare(Student s1,Student s2) { int num = s1.getName().compareTo(s2.getName()); if(num==0) return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); return num; } } class MapTest2 { public static void main(String[] args) { TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator()); //需要将比较器传到容器上 tm.put(new Student("blisi3",23),"nanjing"); tm.put(new Student("lisi1",21),"beijing"); tm.put(new Student("alisi4",24),"wuhan"); tm.put(new Student("lisi1",21),"tianjin"); tm.put(new Student("lisi2",22),"shanghai"); Set<Map.Entry<Student,String>> entrySet = tm.entrySet(); Iterator<Map.Entry<Student,String>> it = entrySet.iterator(); while(it.hasNext()) { Map.Entry<Student,String> me = it.next(); Student stu = me.getKey(); String addr = me.getValue(); System.out.println(stu+":::"+addr); } } }
3.HashMap
获取键值的方法和TreeMap差不多，但是其是无序排列。
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
//并put方法会返回被覆盖的值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wnagwu"));
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey:"+map.containsKey("022"));
//System.out.println("remove:"+map.remove("02"));
System.out.println("get:"+map.get("023"));
map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//获取map集合中所有的值。
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);
}
}
4914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
