集合： 存储对象数据 的集合容器。
集合分类：
1：单例集合
----------| Collection 单例集合 的根接口。
----------------| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。
-------------------| ArrayList ArrayList底层是使用了Object数组实现 的。 特点： 查询速度快，增删慢。
ArrayList内存中是连续的，所以查找时速度快，但是因为移位，所以增删慢
-------------------| LinkedList LinkedList底层是使用了链表数据结构实现的。特点： 查询速度慢，增删快。
-------------------| Vector 底层是使用了Object数组实现 的， 实现原理与ArrayList 是一致的，但是是线程安全的，操作效率低。
----------------| Set 如果是实现了Set接口的集合类，具备的特点： 无序，不可重复。
-------------------| HashSet 底层是使用了哈希表实现 的。 特点： 存取速度快。
HashSet存储元素的原理：
往hashSet添加元素的时候，首先会调用元素的hashCode方法得到元素的哈希码值，然后把哈希码值经过运算算出该元素存在哈希表中的位置。
情况1：如果算出的位置目前还没有存在任何的元素，那么该元素可以直接添加到哈希表中。
情况2： 如果算出的位置目前已经存在其他的元素，那么还会调用元素 的equals方法再与这个位置上 的元素比较一次。
如果equals方法返回的是true，那么该元素被视为重复元素，不允许添加。如果equals方法返回 的是false，那么该元素也可以被添加。
------------------| TreeSet 底层是使用了红黑树（二叉树）数据结构实现的。 特点： 对集合中的元素进行排序存储。
TreeSet要注意的事项：
1. 往TreeSet添加元素 的时候，如果元素具备自然顺序的特点，那么TreeSet会根据元素 的自然顺序特性进行排序 存储。
2. 往TreeSet添加元素 的时候，如果元素不具备自然顺序的特点,那么元素所属的类就必须要实现Comparable接口，把比较的规则定义在CompareTo方法上。
3. 往TreeSet添加元素 的时候，如果元素不具备自然顺序的特点,那么元素所属的类就也没有实现Comparable接口，那么在创建TreeSet对象的时候必须要传入比较器对象。
比较器 的定义格式:
class 类名 implements Comparator{
}
:2：双列集合
----------| Map 存储的数据都是以键值对的形式存在的，键可以不重复，值可重复。
-------------| HashMap 底层也是使用了哈希表实现的。
-------------| TreeMap 底层也是使用了红黑树数据结构实现的。
import java.util.HashSet;
import javax.print.attribute.HashAttributeSet;
class Person{
int id;
String name;
public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public int hashCode() {
return this.id;
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.id == p.id;
}
@Override
public String toString() {
return "编号："+ this.id +" 姓名： "+ this.name;
}
}
public class Demo1 {
public static void main(String[] args) {
HashSet<Person> set = new HashSet<Person>();
set.add(new Person(110,"狗娃"));
set.add(new Person(110,"狗娃"));
System.out.println("集合的元素："+ set);
}
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
public class Demo2 {
public static void main(String[] args) {
ArrayList<String> list =new ArrayList<String>();
//使用get方法遍历。
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println("======get方式遍历=========");
for(int i = 0 ; i < list.size() ; i++){
System.out.print(list.get(i)+",");
}
//使用迭代器 注意： 迭代器在迭代的 过程中不能使用集合对象修改集合中的元素个数。如果需要修改要使用迭代器的方法进行修改，
System.out.println("\r\n======迭代器方式遍历=========");
HashSet<String> set = new HashSet<String>();
set.add("狗娃");
set.add("狗剩");
set.add("铁蛋");
/*Iterator<String> it = set.iterator(); //获取到迭代器
while(it.hasNext()){
System.out.print(it.next()+",");
}
*/
for(String item : set){
System.out.print(item+",");
}
System.out.println("\r\n======entrySet方式遍历=========");
HashMap<String, String> map = new HashMap<String, String>();
map.put("张三","001");
map.put("李四","002");
map.put("王五","003");
Set<Entry<String,String>> entrys = map.entrySet(); //
for (Entry<String,String> entry : entrys) {
System.out.println("键："+entry.getKey()+" 值："+entry.getValue());
}
}
}
下面是一组具体的例子：
package com.imooc.collection;
public class Course {
/**
* @param args
*/
public String id;
public String name;
public Course(){}
public Course(String id, String name){
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.imooc.collection;
import java.util.*;
/**
* 备选课程类
* @author Administrator
*
*/
public class ListTest {
/**
* 用于存放备选课程的List
*/
public List coursesToSelect;
public ListTest() {
/**
* List是一个接口，实现这个接口的有ArrayList，LinkedList，Vector这些类
*/
this.coursesToSelect = new ArrayList<Course>();
}
/**
* 用于往coursesToSelect中添加备选课程
*/
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course cr1 = new Course("1" , "数据结构");
coursesToSelect.add(cr1);
Course temp = (Course) coursesToSelect.get(0);
System.out.println("添加了课程：" + temp.id + ":" + temp.name);
Course cr2 = new Course("2", "C语言");
coursesToSelect.add(0, cr2);
Course temp2 = (Course) coursesToSelect.get(0);
System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);
coursesToSelect.add(cr1);
Course temp0 = (Course) coursesToSelect.get(2);
System.out.println("添加了课程：" + temp.id + ":" + temp.name);
//以下方法会抛出数组下标越界异常
// Course cr3 = new Course("3", "test");
// coursesToSelect.add(4, cr3);
Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 = (Course) coursesToSelect.get(2);
Course temp4 = (Course) coursesToSelect.get(3);
System.out.println("添加了两门课程：" + temp3.id + ":" +
temp3.name + ";" + temp4.id + ":" + temp4.name);
Course[] course2 = {new Course("5", "高等数学"), new Course("6", "大学英语")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp5 = (Course) coursesToSelect.get(2);
Course temp6 = (Course) coursesToSelect.get(3);
System.out.println("添加了两门课程：" + temp5.id + ":" +
temp5.name + ";" + temp6.id + ":" + temp6.name);
}
/**
* 取得List中的元素的方法
* @param args
*/
public void testGet() {
int size = coursesToSelect.size();
System.out.println("有如下课程待选：");
for(int i= 0 ; i < size; i++) {
Course cr = (Course) coursesToSelect.get(i);
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 通过迭代器来遍历List
* @param args
*/
public void testIterator() {
//通过集合的iterator方法，取得迭代器的实例
Iterator<Course> it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while(it.hasNext()) {
Course cr = it.next();
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 修改List中的元素
* @param args
*/
public void testModify() {
coursesToSelect.set(4, new Course("7", "毛概"));
}
/**
* 删除List中的元素
* @param args
*/
public void testRemove() {
// Course cr = (Course) coursesToSelect.get(4);
System.out.println("即将删除4位置和5位置上的课程！");
Course[] courses = {(Course) coursesToSelect.get(4), (Course) coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
// coursesToSelect.remove(4);
System.out.println("成功删除课程！");
testForEach();
}
/**
* 往List中添加一些奇怪的东西
* @param args
*/
public void testType() {
System.out.println("能否往List中添加一些奇怪的东西呢！？");
coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
}
public static void main( String[] args) {
ListTest lt = new ListTest();
lt.testAdd();
// lt.testType();
lt.testForEach();
lt.testGet();
lt.testIterator();
lt.testForEach();
lt.testModify();
lt.testForEach();
lt.testRemove();
}
}
package com.imooc.collection;
import java.util.*;
public class TestGeneric {
public List<Course> courses;
public TestGeneric(){
this.courses = new ArrayList<Course>();
}
public void testAdd(){
Course cr1 = new Course("1", "大学语文");
courses.add(cr1);
// System.out.println("" + cr1.getId() + ":" + cr1.getName());
Course cr2 = new Course("2", "JAVA");
courses.add(cr2);
}
/**
* 测试循环遍历
*/
public void testForEach(){
for(Course cr : courses) {
System.out.println(cr.getId() + ":" + cr.getName());
}
}
public void testChild(){
ChildCourse ccr = new ChildCourse();
ccr.setId("3");
ccr.setName("duixiang");
}
private void testBasicType() {
// TODO Auto-generated method stub
List<Integer> list = new ArrayList<Integer>();
list.add(1);
System.out.println("基本类型必须使用包装类作为泛型" + list.get(0));
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TestGeneric tg = new TestGeneric();
tg.testAdd();
tg.testAdd();
tg.testForEach();
// tg.testChild();
tg.testForEach();
tg.testBasicType();
}
}
4095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
