黑马程序员——Java集合

                             ------- android培训、java培训、期待与您交流！ --------

                                                     集合

  面向对象语言对事物的体现都是以对象的形式，所以方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

  数组虽然也可以存储对象，但长度是固定的，集合的长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。
  集合的特点：集合只用于存储对象，集合的长度可变，集合可以存储不同类型的对象。
  使用collection中方法先import java.util.*;
  添加元素：add();   获取集合长度：size();
  add方法中的参数类型为object，以便于接受任意类型的对象。
  
  集合中存储的都是对象的引用地址。
  删除元素  remove();     清空集合   clear();
 
  contains()   判断集合中是否有对象；   isEmpty();  判断集合是否为空。
  迭代器就是集合取出元素的方式
  Iterator it = al.iterator(); 获取迭代器。
  把取出的方式定义在集合内部，这样取出的方式就可以直接访问集合内的元素。那么出去方式就被定义成内部类了。
Collection
     |——List 特点：元素是有序的，元素可以重复，因为该集合有索引。List集合判断元素是否相同的一句是equals方法。
     |——Set  特点：元素是无序的元素不可以重复。
  凡是可以操作角标的方法都是List体系特有的方法。
  增： add()   addAll()
  删：remove()  改：set()    查：get()    sublist()   listIterator()
    List集合特有的迭代器listIterator()是Iterator的子接口。
    在迭代时不可以通过集合对象的方法来操作集合中的元素。会发生异常。所以在迭代时，只能使用迭代器的方法来操作元素
可是Iterator方法有限只能对元素取出，删除。所以需要其子接口。其子接口listIterator()中有增删改查的方法。
 List
   |——ArrayList    底层数据结构使用的是数组结构。特点查询速度快增删速度稍慢，线程不同步。

import java.util.*;
class ArrayList6 
{
public static void main(String[] args) 
{
ArrayList al = new ArrayList();//创建ArrayList集合
al.add("java01");
al.add("java01");
al.add("java02");//添加元素
al.add("java03");
al.add("java02");
al.add("java03");
sop(al);
al = singleElement(al);
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static ArrayList singleElement(ArrayList al)
{
ArrayList newAl = new ArrayList();

Iterator it = al.iterator();//使用迭代器将集合中的元素都取出来

while(it.hasNext())
{
Object obj = it.next();
if(!newAl.contains(obj))
newAl.add(obj);//新的ArrayList集合不含有这个元素才把它添加进去
}
return newAl;
}
}


   
   |——LinkedList  底层使用的是链层数据结构。特点是增删速度快，查询稍慢。

import java.util.*;
class DuiLie
{
private LinkedList link;


DuiLie()
{
link = new LinkedList();//创建LinkedList对象
}
public void myAdd(Object obj)//定义添加元素方法
{
link.addFirst(obj);//LinkedLis的特有方法
}
public Object myGet()//定义获取删除元素
{
return link.removeLast();
}
public boolean isNull()
{
return link.isEmpty();
}
}


class  LinkedListTest1
{
public static void main(String[] args) 
{
DuiLie dl = new DuiLie();//创建对象
dl.myAdd("java01");
dl.myAdd("java02");//添加元素
dl.myAdd("java03");
dl.myAdd("java04");
dl.myAdd("java05");
while(!dl.isNull())
{
System.out.println(dl.myGet());
} }
}
   |—— vector  底层是数组数据结构，线程同步被ArrayList 取代。
   
  Set：元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复。功能和collection功能一致。
  Set
    |——HashSet：底层数据结构为哈希表。通过元素的两个方法，hashcode和equals来保证元素的唯一性。
    |——TreeSet：特点：可以对集合中的元素进行排序。底层数据结构为二叉树。
  两种排序方式：

                       1：让元素自身具备比较性。实现comparable接口覆盖compareTo方法

                        2：当元素本身不具备比较性，或者具备的比较性不是所需的。这时就要自定义比较器。实现comparator接口复写compare方法
 当两种排序都在时，以比较器为主。

import java.util.*;
class TreeSetTest01 
{
public static void main(String[] args) 
{
//创建TreeSet集合
TreeSet ts = new TreeSet(new MyCompare());
//添加元素
ts.add(new Student("java01",26));
ts.add(new Student("java02",21));
ts.add(new Student("java02",22));
ts.add(new Student("java02",21));
ts.add(new Student("java03",21));
ts.add(new Student("java03",25));


Iterator it = ts. iterator();//使用迭代器取出TreeSet集合中的元素


while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"::::"+stu.getAge());
}
}
}
class MyCompare implements Comparator//自定义比较器
{
public int compare(Object o1,Object o2)//复写compare方法
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;


int num = s1.getName().compareTo(s2.getName());//进行比较
if(num==0)//如果主要条件相同一定要要判断一下次要条件
{
return new Integer(s1.getAge()).compareTo (new Integer(s2.getAge()));
}
return num;
}
}
class Student
{
private String name;
private int age;


Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
   泛型
 泛型格式通过<>来定义要操作的引用数据类型。泛型通常在集合框架中很常见。
 泛型类定义的泛型在整个类中有效，如果被方法使用，那么泛型的对象明确要操作的具体类型后，所要操作的类型就已经固定了。
 
 泛型也可以定义在方法中和接口上。

import java.util.*;
class Test04
{
public static void main(String[] args) 
{
//定义一个装有String类型元素ArrayList集合
List<String> al = new ArrayList<String>();
al.add("java01");//添加元素
al.add("java02");
al.add("java03");
al.add("java04");
al.add("java05");
//使用迭代器取出
Iterator<String> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}


}
}
 泛型限定业用于泛型扩展。
  ? ：通配符，也可以理解为站位符。
  
  ?extends E ：可以接收E类型或者E类型的子类(上限)。
  ? super E：可以接受接收E类型或者E类型的父 类(下限)。
 Map
接口map<k,v>
参数类型
      k——此映射所维护键得类
      v——映射值的类型
 map集合的特点：该集合存储键值对，一对一对往里存，而且要保证键得的唯一性。
 Map
   |——Hashtable ：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。效率较低。
  
   |——Hashmap：底层是哈希表数据结构，允许使用null键null值，该集合是不同步的。效率较高。
   | ——Treemap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序。
  其实Set底层就是使用map集合。如果出现添加时，相同的键，那么后添加的值会覆盖原有的键对应的值。并且put方法会返回被覆盖的值

import java.util.*;
class TreeMapTest01 
{
public static void main(String[] args) 
{
String s = charCount("ab2cda3sd4ee5fr6ty");
System.out.println(s);
}
public static String charCount(String str)
{
char[] chs = str.toCharArray();//将字符串转化成字符数组
//创建TreeMap集合，然后用泛型定义里面装的是Character,Integer类型键值对
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
for(int x = 0; x<chs.length; x++)
{
if(!(chs[x]>='a' && chs[x]<='z'||chs[x]>='A' && chs[x]<='Z'))
continue;
Integer value = tm.get(chs[x]);
if(value==null)
{
tm.put(chs[x],1);//如果value==null就存入，并记录一次
}
else
{
value = value+1;
tm.put(chs[x],value);//记录value = value+1;
}
}
//System.out.println(tm);
StringBuilder sb = new StringBuilder();//定义StringBuilder容器


Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();//把map集合中的元素放入set集合中。


Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();//迭代取出


while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch+"("+value+")");//键值存入StringBuilder集合中


}


return sb.toString();
}
}

哈希表的原理：

1，对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值 称为哈希值。

2，哈希值就是这个元素的位置。

3，如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。

4，存储哈希值的结构，我们称为哈希表。

5，既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。

这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。

对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。

对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

         1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。

         2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。

方法：

1：添加。

 put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

2：删除。

void clear()：清空

value remove(key) ：删除指定键。

3：判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value) ：是否包含value

4：取出。

int size()：返回长度

value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection values()：获取map集合中的所有的值。

5：想要获取map中的所有元素：

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

Set keySet();

Set entrySet();//取的是键和值的映射关系。

Entry就是Map接口中的内部接口；

为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

取出map集合中所有元素的方式一：keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

Set keySet = map.keySet();

Iterator it = keySet.iterator();

while(it.hasNext()) {

Object key = it.next();

Object value = map.get(key);

System.out.println(key+":"+value);

}

取出map集合中所有元素的方式二：entrySet()方法。

Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();

Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();

while(it.hasNext()) {

Map.Entry  me = (Map.Entry)it.next();

System.out.println(me.getKey()+"::::"+me.getValue());

｝

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

静态方法：

Collections.sort(list);//list集合进行元素的自然顺序排序。

Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。

class ComparatorByLen implements Comparator<String>{

public int compare(String s1,String s2){

int temp = s1.length()-s2.length();

return temp==0?s1.compareTo(s2):temp;

}

}

Collections.max(list); //返回list中字典顺序最大的元素。

int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。

Collections.reverseOrder();//逆向反转排序。

Collections.shuffle(list);//随机对list中的元素进行位置的置换。

将非同步集合转成同步集合的方法：Collections中的  XXX synchronizedXXX(XXX);

List synchronizedList(list);

Map synchronizedMap(map);

原理：定义一个类，将集合所有的方法加同一把锁后返回。

Collection 和 Collections的区别：

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。

Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。

String[] arr = {"abc","kk","qq"};

List<String> list = Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；

可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set； 

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。

如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

集合变数组：用的是Collection接口中的方法：toArray();

如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。

如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。

所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。

                                ------- android培训、java培训、期待与您交流！ ----------