---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
Collection集合类，用来存储对象的引用，也就是内存地址值。
Collection
|---List 元素是有序的，元素可以重复，
|--ArrayList：底层的数据使用的是数组结构，线程不同步。
特点：查询速度很快，但是增删数据稍慢
|--LinkedList：底层使用的是链表数据结构
特点:增删速度很快，查询稍慢
|--Vector ：底层是数组数据结构，线程同步，较安全。
|---Set：元素是无序的，元素不可以重复。
|--HashSet：底层数据结构是哈希表
HashCode如何保证元素唯一性：
通过元素的两个方法，HashCode和equals来完成。
如果HasCode值相同，才会判断equals是否是true
如果HasCode值不同，不会调用equals方法。
对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法
|--TreeSet
Map
|--HashTable:底层是哈希表数据结构，不可以存入null键null值。线程同步。效率低。JDK1.0
|--HashMap：底层是哈希表数据结构，允许null键和null值。非同步，效率高。JDK1.2
|--TreeMap：底层是二叉树，线程不同步。可以用于给map集合中的键进行排序。
List:特有方法：凡是可以操作角标的方法都是该体系结构特有的方法。
1、 增加
add(index,element)
addAll(index,collection)
2、 删除
remove(index)
3、 修改
set(index,element)
4、查询
get(index,element)
subList(from,to)
listIterator()
List集合特有的迭代器，ListIterator是iterator子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代时，只能用迭代器的 方法操作元素，可以Iteratir方法是有局限的，
只能对元素进行判断，取出，删除操作。
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator.
该接口只能通过List集合的ListIterator获取。
Set:元素是无序的（存入和取出的顺序不一定），元素不可以重复。
set和collection的功能是一致的。
集合中使用迭代器取出元素，也就Iterator.
iterator提供hasNext()和next()方法
TreeSet：可以对set集合中的元素进行排序。
* 底层数据结构是二叉树，保证元素唯一性的依据是：compareTo方法的return 0;`
* 这种方式也称为元素的自然顺序，或者叫默认顺序。
*
* TreeSet排序的第一种方式;让元素自身具备比较性，
* 元素需要实现Comparable接口，覆盖CompareTo方法。
* 排序时，当主要条件相同时，一定要判断一下次要条件。
*
* TreeSet排序的第二种方式：
* 当于元素不具备比较性时，或者具备的比较性不是所需要的时。
* 这时就需要让集合自身具备比较性。
* 在集合初始化时，就有了比较方式。使用构造函数。
Map集合：该集合存储键值对。一对一对存数据，而且保证键的唯一性。
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。
1、添加
put(K key,V value)
putAll(Map<? extends K,? extends V> m)
2、删除
clear()
remove(Object key)
3、判断
containsKey(Object key)
containsValue(Object value)
isEmpty()
4、获取
get(Object key)
size()
values()
entrySet()
KeySet()
map和set很像，而且set底层就是使用了Map集合。
Map集合的两种取出方式：
1、Set<K> KeySet:将Map中所有的键存入到Set集合中，，因为Set具备迭代器，
所以可以迭代方法取出所有的值，再根据get方法，获取每一个键对应的值。
map集合取出原理：将map集合转成set集合，再 用迭代器取出。
2、Set<Map,Entry<K,V> > EntrySet:将Map集合中的映射系存储到set集合中，而这个关系的数据类型就是Map.Entry，
在Map.Entry中通过getKey和getValue获取内容。
Map.Entrry 其实Entry也是一个接口，它是Map接口中的一个内部接口.
集合类体系结构图例：
ArrayList方法演示，代码如下：
package com.itheima.day14;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo
{
/*
Collection
|---List 元素是有序的，元素可以重复，
|--ArrayList：底层的数据使用的是数组结构，线程不同步。
|--LinkedList：底层使用的是链表数据结构
|--Vector ：底层是数组数据结构，线程同步，较安全。
|---Set：元素是无需的，元素不可以重复。
|--HashSet：底层数据结构是哈希表
|--TreeSet
List:
特有方法：凡是可以操作角标的方法都是该体系结构特有的方法。
1、增加
add(index,element)
addAll(index,collection)
2、删除
remove(index)
3、 修改
set(index,element)
4、查询
get(index,element)
subList(from,to)
listIterator()
*/
public static void main(String[] args)
{
method_add();
method_listIterator();
}
public static void method_add()
{
ArrayList a1 = new ArrayList();
//添加元素
a1.add("a");
a1.add("b");
a1.add("c");
print("原集合是："+a1);
//在指定位置添加元素
a1.add(1, "kk");
//删除指定位置的元素
a1.remove(2);
//修改元素
a1.set(1, "dd");
//通过角标获取元素
print("get(1):"+a1.get(1));
//获取所有元素
for(int i=0; i<a1.size(); i++)
{
System.out.println("a1.get("+i+")="+a1.get(i));
}
//迭代器获取所有元素
Iterator it = a1.iterator();
while(it.hasNext())
{
print(it.next());
}
//通过indexOf()获取对象的位置
print("index="+a1.indexOf("dd"));
//返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
List sub = a1.subList(1, 3);
print("sub="+sub);
}
public static void method_listIterator()
{
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
/*
Iterator it = a1.iterator();
//在迭代过程中，增加或者删除元素
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java02"))
{
it.remove();//将java2de引用从集合中删除
//a1.add("java04");抛出ConcurrentModificationException异常
print("obj="+ obj);
}
}
*/
//演示列表迭代器。ListIterator具备增删改查功能。
ListIterator li = a1.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
print("obj="+obj);
}
print(a1);
// boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 同hasNext()相反，向前遍历
print("a1.hasPrevious()="+li.hasPrevious());
}
public static void print(Object obj)
{
System.out.println(obj);
}
}
HashSet方法演示，代码如下：
package com.itheima.day14;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest
{
/*
* 举例：
* 将自定义的对象作为元素存储到HashSet集合中，并去除重复数据。
* 比如：存储人对象，同姓名同年龄，视为同一个人，为重复数据。
*/
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person2("a1",1));
hs.add(new Person2("a2",2));
hs.add(new Person2("a3",3));
hs.add(new Person2("a2",2));
// System.out.println(hs.contains(new Person("a1",1)));
hs.remove(new Person("a3",3));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person2 p = (Person2)it.next();
System.out.println(p.getName()+"--"+p.getAge());
}
}
}
class Person2
{
private String name;
private int age;
Person2(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()
{
System.out.println(this.name+"===hashcode");
return name.hashCode()+age*20;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person2))
return false;
Person2 p = (Person2)obj;
System.out.println(this.name+"**eqauls**"+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}将自定义的对象作为元素存储到ArrayList集合中，并去除重复数据。
比如：存储人对象，同姓名同年龄，视为同一个人，为重复数据。
代码如下：
package com.itheima.day14;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 举例：
* 将自定义的对象作为元素存储到ArrayList集合中，并去除重复数据。
* 比如：存储人对象，同姓名同年龄，视为同一个人，为重复数据。
*
* 思路：
* 1、对人描述，将数据封装成人对象。
* 2、定义容器，将人存入
* 3、取出。
*
* List集合判断两个集合是否相同，根据的是元素的equals方法
* @author kevin
*
*/
public class ArrayListTest2 {
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add(new Person("zhangsan",20));
al.add(new Person("lisi",22));
al.add(new Person("lisi",22));
al.add(new Person("crystal",23));
al.add(new Person("zhangsan",20));
al.add(new Person("andrea",20));
al = singleElement(al);
Iterator it = al.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();//必须向下转型为Person,否则异常
System.out.println(p.getName()+"--"+p.getAge());
}
}
public static ArrayList singleElement(ArrayList al)
{
ArrayList newal = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())//迭代中next一次就判断一次
{
Object obj = it.next();
if(!newal.contains(obj))//contains底层调用equals方法
newal.add(obj);
}
return newal;
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
// System.out.println(this.name+"--"+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
LikedList常用方法：
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
boolean offerFirst(E e)
在此列表的开头插入指定的元素。
boolean offerLast(E e)
在此列表末尾插入指定的元素。
E peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E removeFirst()
移除并返回此列表的第一个元素。
E removeLast()
移除并返回此列表的最后一个元素。
E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
package com.itheima.day14;
import java.util.LinkedList;
public class LinkedListDemo
{
/**
*链表特有方法；
*
*addFirst()
*addLast()
*
*getFirst()
*getLast()
*获取元素，但是不删除数据
*
*removeFirst()
*removeLast()
*获取元素，但是删除元素
*如果集合中没有元素，会出现NoSuchElementException异常，
*
*在JDK1.6或出现了替代方法.
*offerFirst()
*offerLast()
*
*peekFirst()
*peekLast()
*
*pollFirst()
*pollLast()
*如果集合中没有元素，会返回null
*
*
* @param args
*/
public static void main(String[] args)
{
LinkedList lk = new LinkedList();
lk.addFirst("java01");
lk.addFirst("java02");
lk.addFirst("java03");
System.out.println(lk);
/*
* 输出：[java03, java02, java01]
* 后面Add的数据放在原数据前面
*/
System.out.println(lk.getFirst());
System.out.println(lk.getLast());
//System.out.println(lk.removeFirst());
System.out.println("size="+lk.size());
while(!(lk.isEmpty()))
{
System.out.println(lk.removeLast());
}
System.out.println("size="+lk.size());
}
}
Vector举例，代码如下：
package com.itheima.day14;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo
{
/**Enumeration是Vector特有的取出数据的方式，和Iterator功能相似。
* 因为枚举的名称和方法的名称都过长，所以被Iterator取代了.
* 枚举是vector中特有的迭代方法。
* @param args
*/
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
TreeSet举例：按照字符串长度排序。
代码如下：
package com.itheima.day15;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/**
* 举例：按照字符串长度排序
*
* 字符串本身具有比较性，但是它得比较方式不是所需要的。
* 这时就需要使用比较器。
* @author kevin
*
*/
public class TreeSetTest
{
public static void main(String[] args)
{
TreeSet tree = new TreeSet(new StrLenCompare());
tree.add("a");
tree.add("dc");
tree.add("bba");
tree.add("bbc");
Iterator it = tree.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenCompare implements Comparator
{
@Override
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;
return -1;*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}package com.itheima.day16;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
/*
Map集合的两种取出方式：
1、Set<K> KeySet:将Map中所有的键存入到Set集合中，，因为Set具备迭代器，
所以可以迭代方法取出所有的值，再根据get方法，获取每一个键对应的值。
map集合取出原理：将map集合转成set集合，再 用迭代器取出。
2、Set<Map,Entry<K,V> > EntrySet:将Map集合中的映射系存储到set集合中，而这个关系的数据类型就是Map.Entry，
在Map.Entry中通过getKey和getValue获取内容。
Map.Entrry 其实Entry也是一个接口，它是Map接口中的一个内部接口.
interface Map
{
public static infterfaceEntry
{
public static abstract Object getKey();
public static abstract Object getValue();
}
}
class HashMap implements Map
{
class HashDemo implement Entry
{
public static Object getKey(){}
public static Object getValue({}
}
}
*/
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01", "java01");
map.put("02", "java02");
map.put("03", "java03");
//EntrySet方法演示
//将Map集合中的映射关系取出，存入到Set集合中。
Set<Map.Entry<String, String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String, String> me = it.next();
//关系对象Map.Entry<K, V>中封装有getKey和getValue方法
String key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
/*
* KeySet方法演示
//先获取map集合中的所有键set集合，keySet
Set<String> keyset = map.keySet();
//有了set集合，就可以获取其迭代器
Iterator<String> it = keyset.iterator();
while(it.hasNext())
{
String key = it.next();
System.out.println("key="+key);
//由来map键就可以使用map的get方法获取没有个键对饮的值
String value = map.get(key);
System.out.println("value="+value);
}
*/
}
}
扫一扫
5254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
