06java基础之集合

一、集合框架：

(1)为什么出现集合类？

面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。

集合就是存储对象最常用的一种方式.
(2)数组和集合都是容器，两者有何不同？

数组长度固定，而集合长度是可变的

数组值可以存储对象，还可以存储基本数据类型;而集合只能存储对象

数组存储数据类型是固定的，而集合存储的数据类型不固定

(3)集合类的特点：

集合只能存储对象

集合的长度是可变的

集合可以存储不同类型的对象

Collections.sort(shopCar,new GoodsComparator());

注意： . Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。根据内存地址判断，不跟距内容判断相同。

1、List:列表，元素是有序的(元素带角标索引)，可以有重复元素,可以有null元素

1.ArrayList: 底层是数组（有序，可重复）可以有null元素。

增：add，addAll,

删：remove, clear

改：set

查：get，size，isEmpty,，contains

注意：使用Iterator进行迭代，hasnext() ,next()

2.LinkedList: 底层是链表（有序，可重复）

增：add，addAll，addFirst，addLast

删：clear，remove

改：set

查：get，getFirst，getLast，size/

2、 Set:集合，元素是无序的(因为没有索引)，元素不可以重复。可以有null元素。

3、 HashSet: 底层是哈希表，来源于HashMap（无序，不可重复）

增：add

删：clear，remove

改：

查：contains，isEmpty，size

List使用注意！
|--->ArrayList:
(1)当往ArrayList里面存入元素没什么要求时，即只要求有序就行时；

(2)当往ArrayList里面存入元素要求不重复时，比如存入学生对象，当同名同姓时
视为同一个人，则不往里面存储。则定义学生对象时，需复写equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
则往ArrayList集合通过add存入学生对象时，集合底层自己会调用学生类的equals方法，
判断重复学生则不存入。
注：对于List集合，无论是add、contains、还是remove方法，判断元素是否相同，
都是通过复写equals方法来判断！

(1)HashSet注意:
通过new的方式往HashSet里面存的元素的hashCode都不同，但通常我们定义对象，
比如学生对象时，虽然是new的两个学生对象，但是当他们name和age一样时，我们认为是
同一个对象，所以为了保证元素的唯一性，我们通常在往HashSet集合里面存储元素时，
在定义对象的类中通常复写hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}

HashSet是如何保证元素唯一性的呢？
**如果两元素的hashCode值不同，则不会调用equals方法
**如果两元素的hashCode值相同，则继续判断equals是否返回true；
**hashCode和equals方法虽然定义在自定义对象类里面，但不是我们手动调用
而是往HashSet集合里面存储元素的时候，集合底层自己调用hashCode和equals
它自己拿对象去判断，自己判断两元素是否是同一个元素。

注意：使用iterator进行迭代

Map:顶层接口,该集合存储的是键值对,而且键是唯一的,Map和Set很像,Set集合底层就是使用了Map集合。
Map集合没有迭代器，要取出元素必须先将Map集合转换成Set集合才能遍历元素
|--->HashTable(JDK1.0):
底层是哈希表数据结构；
不可以使用null键和null值；
用作键的对象必须实现hashCode和equals方法来保证键的唯一性
线程同步，效率低
|--->HashMap(JDK1.2):
底层是哈希表数据结构；
允许使用null键和null值；
线程不同步，效率高；
保证元素唯一性的:
原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true
(往HashSet里面存的自定义元素要复写hashCode和equals方法，
以保证元素的唯一性！)

3、Map

Map<String, Student> map =new HashMap<String, Student>()；

2 存储数据:put

map.put("jredu001", new Student("jredu001","张三",20));

3 集合大小: map.size();

4 删除： map.remove("jredu001"); map.clear();

5 遍历

            1、所有keys
		      Set<String> keys = map.keySet();
		      for(String key:keys){
			    Student stu= map.get(key);(值values)
			    System.out.println(stu.getId());
		     }
		     System.out.println("***************");
		2、values 
		      Collection<Student> stus= map.values();
		       for(Student stu :stus){
			System.out.println(stu.getId())}
                3、key+values
                public void showJob() {
		           for (Job job : jobs.keySet()) {
			        System.out.println(job.getJobid() + "\t" + job.getJobName() + "\t"
					                      + job.getPub_date() + "\t" + job.getCatgory() 
					                       + "\t"+jobs.get(job).intValue());
		}
		
		}

4、Iterator：

对collection进行迭代的迭代器.迭代器取代了Enumeration。
迭代器和枚举的区别：
迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的collection移除元素
方法名称得到了改进，简化书写
**LisIterator：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表
**Comparable：此接口强行对实现它的每个类的对象进行整体自然排序。使元素具备比较性
**Comparator：强行对某个对象collection进行整体排序的比较函数，使集合具备比较性
**Collections：此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
**Arrays：此类包含用来操作数组(比如排序和搜索)的各种静态方法

5、静态导入：
**import static java.util.Arrays.* 导入的是Arrays这个类中所有的静态方法
**当类名重名时，需要制定具体的报名
**当方法重名时，需要制定具体所属的对象或者类
6、Collections类：
(1)此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
(2)静态方法摘要：
static <T> boolean addAll(Collection<? super T> c, T... elements)
将所有指定元素添加到指定 collection 中。
static <T> void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list)
反转指定列表中元素的顺序。
static <T> Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
(3)Collections类特牛的方法：
集合有一个共同的缺点，那就是线程不安全，被多线程操作时，容易出现问题，虽然可以自己加锁
但是麻烦。Collections提供特牛的方法，就是给它一个不同步的集合，它返回一个同步的安全的集合

static <T> Collection<T> synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T> synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。
7、Arrays类：
此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态方法。
如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
(1)静态方法摘要：
static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。
注意：
A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！
如果增删，则发生UnsupportedOprationException(不支持操作异常)
B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个
元素出入集合
C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成
集合中的元素
8、数组变集合以及集合变数组的对比：
(1)数组变集合：
方法：static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。
好处：可以使用集合的思想和方法操作数组中的元素，数组是一个对象，但是数组中的功能很少
(2)集合变数组：
方法：Collction中的toArray方法
好处：可以限定对集合元素的操作，防止对集合的元素进行增删，因为数组长度是固定的。

9、Collections类和Arrays类的使用。(重点)
A:Collections
排序
二分查找
发转
B:Arrays
把数组变成字符串输出
排序
二分查找

猜你喜欢