Collection

   

List集合

   

/**

* 集合中常见的方法：

* boolean add(object element) 向集合中添加元素

*

*addAll() 将集合的所有元素加到

* void clear() 清空集合

* boolean contains(Object o) 看集合中是否包含某个元素

* Iterator<E> iterator() 获取集合所属的迭代器

* boolean Remove(Object o) 删除某个元素

* int size() 获取集合大小

* Object[] toArray();将集合转换成数组

*

*

*/

   

以上方法的详解：

//创建集合

Collection c=new ArrayList();//多态 父类型引用指向子类型对象

 

//添加元素

c.add(1);

 

//获取集合大小

System.out.println(c.size());

 

//是否为空

System.out.println(c.isEmpty());

 

//将集合        转化为 Object 数组

c.toArray();

 

//清空

c.clear();

   

   

//关于contains() 方法：

Integer i1=new Integer(10);

c.add(i1);

   

System.out.println(c.contains(i1));//true

   

Integer i2=new Integer(10);

   

System.out.println(c.contains(i2));//true

//原因，contains 方法底层调用的是equals 方法，如果 equals 返回的是 true表明就是包含

//存储在集合中的对象都要重写 equals 方法

   

   

//关于 remove 方法：重写 equals 方法，以及remove() 方法的详解：

   

Integer i3=new Integer(16);

c.add(i3);

   

Integer i4=new Integer(16);

c.remove(i4);//0

   

System.out.println(c.size());//0

原因：在调用remove() 方法时，是按照equals 方法查找，找到与要移除的元素相等的就移除

以上i3,i4 的值相等，所以c.remove(i4 ) 实际上是 c.remove(16).

   

   

/**

* collection 的remove 和 Iterator 的remove 有什么区别

* 当使用 collection的方法删除元素之后，删除了一个元素之后，collection 的Iterator 就改变了需要生成另一个 迭代器

* 所以推荐使用 iterator 的remove 方法。

*

*/

   

//创建一个集合

Collection c = new ArrayList();

//添加元素

c.add(1);

c.add(2);

c.add(3);

//声明一个 迭代器

Iterator it = c.iterator();

   

while (it.hasNext()) {

it.next();

it.remove(); //调用 迭代器的remove() 方法

   

/**

* Object o=it.next();//调用集合的 remove() 方法

* c.remove(o);

*/

   

}

   

关于List 的子类 ArrayList Vector LinkedList 的详解：

   

   

/**

* List 集合的特点：

*                 元素有序 （有下标，可以通过下标访问）,存进去是什么样的，就是什么样的

*                 元素可重复

* 常见方法：

*                 add();//在列表尾部添加元素

*

* ArrayList()

*                  底层是由数组实现，默认长度是 10 ，扩大之后的容量为原来的1.5倍

*                 ArrayList add(int index,E element); //在列表的指定位置添加元素

* vector 集合，底层默认初始化，容量也是10，扩大之后的容量是原来的两倍

* 如何优化：

*                 尽量减少扩容操作，因为扩容需要数组拷贝，数组拷贝很消耗内存，

*

*

*/

//创建list

List l=new ArrayList();

//添加元素

l.add(1);

l.add(32);

l.add(1,555);//在下标为1 的地方添加 555

System.out.println(l.get(0));//取出下标为0 的元素

   

//遍历方法一

Iterator it=l.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

   

//遍历方法二

for(int i=0;i<l.size();i++){

Object element=l.get(i);

System.out.println(element);

}

   

   

关于Set

   

   

/**

* HashStet 底层是HashMap,hashMap 底层就是散列表/hash表

*                 hash表示数组和单向链表的结合，hash表本质是一个数组，只不过这个数组中的元素是一个单向链表

*                 链表的结构是这样的         Object key,

*                                         Object value;

*                                         final int hash;

*                                         Entry next;

*                 添加元素的方法：void put(Object key,Object value)

*                         添加元素时，通过hash 函数，计算出key 的hashcode 值，然后和已有的 hashcode值进行比较：

*                         如果存在，就在hashcode 值相等的这个链表之中依次比较value值，如果value值夜相等，那么这个元素就已经存在，不用添加

*                         如果value值不相等，则把这个元素添加到链表的后面。

*                         如果在value 的hashcode 值从一开始就不存在，就把这个元素加到数组的后面。

*                 查询元素的方法：Object get(Object key)

*                         计算出key 的hashcode 值，然后再根据hashcode 值进行定位，如果hashcode不存在，则不存在这个元素

*                         如果hashcode存在，然后就在相同hashcode的这个链表中 比较value 的值

*

*                         

*

*/

* 5.hashmap和hashset的默认初始化容量都是 16，默认的加载因子为0.75 （）

* 什么是加载因子： 简单的说，设，一个数组长度为100，加载因子为0.75 ，当数组加载到75时，数组就开始扩容

/**

* 关于往Set集合中存储的元素，该元素的 hashcode() 和equals() 方法

* hashmapz中有一个put 方法，put(key,value),key 是无序不可重复的

*

* 当往hashset()以及hashMap() 中添加元素的时候需要重写，equals() 以及hashCode()方法

*/

 

   

   

TreeSet

   

/**

* SortedSet 是继承自set 的一个接口

* java.util.set 父接口

*                 java.util.sortedSet 子接口 无序不可重重复，就是，那个啥，存入数组之后会按元素值得大小排序。可以排序的有，数字，字符串，日期

*                         java.util.TreeSet 实现类

*

* sorted 是如何实现排序的         

*                 因为被存储的元素实现了comparable 接口

*                 sun编写TreeSet 集合在添加元素的时候，会调用CompareTo()

* 有两种方法：

*                 一种是实现comparable 接口，然后实现那个什么的 compareTo方法

*                 

*                 一种是单独编写一个比较器，就是 实现 comparator接口,推荐使用， 单独写一个比较器。

*

*/

eg：

public class User implements Comparable{//实现comparable 接口

   

int age;

   

public User(int age) {

this.age = age;

}

   

@Override

public String toString() {

return "User [age=" + age + "]";

}

   

   

public int getAge() {

return age;

}

   

public void setAge(int age) {

this.age = age;

}

   

/**

* 实现java.util.Comparabl，接口中的就是 compableTo()方法

* comaparable 底层是二叉树

*/

@Override

public int compareTo(Object o) {

int age1=this.age;

int age2=((User)o).age;

return age1-age2;

}

   

}

   

Eg：

public class Product {

double prices;

   

@Override

public String toString() {

return "Product [prices=" + prices + "]";

}

   

public Product(double prices) {

this.prices = prices;

}

   

public double getPrices() {

return prices;

}

   

public void setPrices(double prices) {

this.prices = prices;

}

   

   

}

   

   

//重写一个 Comparator 接口，就是重新写一个 Comparator

class ProductComparator implements Comparator{

@Override

public int compare(Object o1, Object o2) {

double prices1=((Product)o1).prices;

double prices2=((Product)o2).prices;

if(prices1==prices2){

return 0;

}else if(prices1>prices2){

return 1;

}else{

return -1;

}

}

   

}