黑马程序员_java学习日记_Java基础_集合框架
<!--[endif]-->
@SuppressWarnings("unchecked")
??? publicstaticvoid main(String[] args) {
?????? List list = new ArrayList();
?????? //增
?????? list.add(0, "a");
?????? list.add(1, "b");
?????? list.add(2, "c");
?????? list.add(3, "d");
?????? Iterator it = list.iterator();
?????? //删
?????? list.remove(2);
?????? //改
?????? list.set(3, "333");
?????? //查
?????? list.get(4);
??????
?????? //for循环性能更优化些，
?????? for(Iterator i = it; it.hasNext();)
?????? {
??????????
?????? }
??? }
列表迭代器listIterator
在通过Iterator进行迭代的时候，该集合有两种可操作路径，一种是集合本身，一种是迭代器，不能同时用两种方式进行迭代
publicstaticvoid main(String[] args) {
?????? List list = new ArrayList();
?????? list.add("a");
?????? list.add("b");
?????? list.add("c");
?????? list.add("d");
?????? //iterator的子接口，在迭代时不可以通过集合的方式来操作数据
?????? //会发生异常，只能用迭代器的方法操作元素，iterator方法有限
?????? //如果想要添加修改，就需要使用其子接口listIterator
?????? ListIterator it = list.listIterator();
?????? for(ListIterator i = it;i.hasNext();)
?????? {
?????????? Object obj = i.next();
?????????? if(obj.equals("c"))
?????????? i.add("a");
?????????? System.out.println(i.hasPrevious());
?????? }
?????? System.out.println(list);
??? }
ArrayList，LinkList,Vector的底层数据结构
ArrayList：查询快，增删慢，线程不同步，默认长度10，超过10之后，创建一个长度为15的新元素，然后将旧的数组拷贝过去，再添加新元素。
LinkList：增删快，查询慢
Vector：：底层是数组，Vector是同步的，增删查询都慢。默认长度10，超过10之后，创建一个长度为两倍的集合然后。。。
Vector v = new Vector();
?????? v.addElement("a");
?????? v.addElement("b");
?????? v.addElement("c");
?????? //枚举是Vector的特有取出方式，
?????? //迭代器，遍历，枚举
?????? Enumeration e =v.elements();
LinkList
特有方法：addFirst，addLast，removeFirst，removeLast
getFirst,getLast 获取不删除 如果集合为空抛异常
removeFirst,removeLast 获取并删除，该方法也有返回值 如果集合为空抛异常
offerFirst，offerLast，peekFirst，peekLast，pollFirst,pollLast 1.6版本出现，removeFist如果集合为空抛异常，而该方法返回null
设计增删和查询建议ArrayList，最常见 最长频率
Set接口：无顺序，不重复，set方法取出只能使用迭代器
HashSet：底层数据结构是哈希表，线程非同步
?????? 哈希Set通过hashCode和equals来完成的，如果hashCode相同才会判断equal是否为true，如果不同则不会调用equals方法
hashSet对于判断元素是否存在，以及删除，依赖的是hashcode和equals方法，先hashcode后equals
arrayList是通过equals来判断，
TreeSet：底层二叉树
它有自己的特殊顺序，即阿斯科码表的大小顺序
如果想对某个类进行排序，这个类必须具有比较性，即实现一个接口
class student implements Comparable//该接口让该类具有比较性
{
privateintage;
?
?
@Override
publicint compareTo(Object o) {
//当主要条件相同时，一定要判段次要条件
??? if(o instanceof student)
??? {
?????? student s = (student)o;
?????? if (this.age > s.getAge())
?????? {
?????????? return -1;
?????? }elseif(this.age < s.getAge())
?????? {
?????????? return 1;
?????? }else{
?????????? return 0;
?????? }
??? }
??? return 0;
}
String也已经实现了compareable接口，所以可以比较
二叉树减少比较次数用来提高效率，大的向右放
怎么存进去就怎么取出来，只要compareto方法返回值为1即可
TreeSet集合的第二种排序方式，当元素自身不具备比较性，或者具备的比较性不是所需要的，则集合自身需要具有比较性?
publicclass StaticDemo
{
??? @SuppressWarnings("unchecked")
??? //当两种排序都存在的时候以比较器为主
??? publicstaticvoid main(String[] args) {
?????? TreeSet ts = new TreeSet(new compare());
?????? ts.add(new Student("a1"));
?????? ts.add(new Student("a2"));
?????? ts.add(new Student("a3"));
?????? System.out.println(ts);
?????? for(Iterator it1 = ts.iterator();it1.hasNext();)
?????? {
?????????? Student s = (Student)it1.next();
?????????? System.out.println(s.getName());
?????? }
??? }
}
?
@SuppressWarnings("unchecked")
class compare implements Comparator
{
?
??? @Override
??? publicint compare(Object o1, Object o2) {
?????? Student s1 = (Student)o1;
?????? Student s2 = (Student)o2;
?????? return s1.getName().compareTo(s2.getName());
??? }
???
}
class Student
{
??? private String name;
??? public Student(String name)
??? {
?????? this.name = name;
??? }
?
??? public String getName() {
?????? returnname;
??? }
?
??? publicvoid setName(String name) {
?????? this.name = name;
??? }
}
集合类型中如果添加基本数据类型，会触发自动装箱
泛型是为了让该问题在编译阶段就被阻止而产生的，是一个用于解决安全问题的一个安全机制
好处1.安全 2.避免了类型转换的麻烦
publicstaticvoid main(String[] args) {
?????? List<String> list = new ArrayList<String>();
?????? list.add("a1");
?????? list.add("a2");
?????? list.add("a3");
?????? list.add("a4");
?????? for(Iterator<String> it = list.iterator();it.hasNext();)
?????? {
?????????? System.out.println(it.next().length());
?????? }
??? }
通常在集合框架中常见泛型，<>就是用来接收类型的
??? /**
??? ?* @param args
??? ?*/
??? publicstaticvoid main(String[] args) {
?????? TreeSet<Student01> list = new TreeSet<Student01>();
?????? list.add(new Student01("a1"));
?????? list.add(new Student01("c222"));
?????? list.add(new Student01("a133"));
?????? list.add(new Student01("b134"));
?????? for(Iterator<Student01> it = list.iterator();it.hasNext();)
?????? {
?????????? System.out.println(it.next().getName());
?????? }
??? }
}
class Student01 implements Comparable
{
public Student01(String name) {
?????? super();
?????? this.name = name;
??? }
private String name;
@Override
publicint compareTo(Object o) {
??? Student01 s = (Student01)o;
??? returnthis.name.compareTo(s.getName());
}}
泛型类：当类中要操作的引用数据类型不确定的时候，早期定义object来完成扩展，现在定义泛型
泛型类的泛型对整个方法有效，如果被方法使用，如果泛型类的泛型确定，则所有方法的类型参数固定，为了让不同方法操作不同类型，可以将泛型定义在方法上
??? publicstaticvoid main(String[] args) {
?????? Util<Student01> u = new Util<Student01>();
?????? u.setSs("ss");
??? }
?
}
@SuppressWarnings("hiding")
class Util<Student01>
{
??? private Student01 ss;
?
??? public Student01 getSs() {
?????? returnss;
??? }
?
??? publicvoid setSs(Student01 ss) {
?????? this.ss = ss;
??? }
}
泛型方法01
class Util
{
??? public <T> void out(T t)
??? {
?????? System.out.println(t);
??? }
??? public <Q> void set(Q q)
??? {
?????? System.out.println(q);
??? }
}
泛型方法02
class Util<T>
{
??? public? void out(T t)
??? {
?????? System.out.println(t);
??? }
??? public <Q> void set(Q q)
??? {
?????? System.out.println(q);
??? }
}
静态方法不可以访问类上定义的泛型，如果引用数据类型不确定，可以讲泛型定义在方法上
泛型放在方法上放在返回值类型前面
泛型定义在接口上
泛型限定，好处，提高了扩展性，缺点，无法使用特定方法
? extends E 可以接受E类型或者E的子类型上限
? super E 可以接受E类型或者E的父类型下限
??? publicstaticvoid main(String[] args) {
?????? test02 t = new test02();
?????? ArrayList<String> list = new ArrayList<String>();
?????? list.add("a");
?????? list.add("b");
?????? list.add("c");
?????? t.Iterator(list);
?????? ArrayList<Integer> list1 = new ArrayList<Integer>();
?????? list1.add(1);
?????? list1.add(2);
?????? list1.add(3);
?????? t.Iterator(list1);
??? }
//public void<T> Iterator(ArrayList<T> li)
publicvoid Iterator(ArrayList<?> li)
{
??? Iterator it = li.iterator();
??? while(it.hasNext())
??? {
?????? System.out.println(it.next());;
??? }
}
Map集合
一对一对存，而且键不能重复
添加
Put
putAll
删除
Remove
clear
判断
containsKey
containsValue
获取
Size
Get
Values
HashTable 底层是哈希表，不能用null做键值 同步的 效率低
HashMap ?允许使用null做键值，不同步 效率高
TreeMap 二叉树 非同步，可以用于给map集合中的键进行排序
其实set底层使用map集合实现的
Map<String,String> map = new HashMap<String, String>();
?????? map.put("1", "01");
?????? map.put("2", "02");
?????? map.put("3", "03");
?????? System.out.println(map.containsKey("1"));
?????? //返回该键对应的值
?????? //System.out.println(map.remove("2"));
?????? //可以通过get判断是否存在
?????? //System.out.println(map.get("2"));
?????? //如果存入重复的键，则put方法会将(原来的值)返回来
?????? System.out.println(map.put("1", "333"));
?????? Collection c = map.values();
?????? System.out.println(c);
Keyset：将map中所有的键存入set集合，因为set具备迭代器，所以可以根据迭代方式取出所有的键然后get出对应的值
Map集合的取出原理，将map集合转换成set集合，然后通过迭代器取出，
Set<String> set = map.keySet();
?????? Iterator<String> it = set.iterator();
?????? while(it.hasNext())
?????? {
?????????? System.out.println(map.get(it.next()));
?????? }
entrySet：将集合中的映射关系取出，这个映射关系就是Map.entry（关系类型）
map扩展：map被使用是因为他具备映射关系，
publicstaticvoid main(String[] args) {
?????? Map<String,String> map = new HashMap<String, String>();
?????? map.put("1", "01");
?????? map.put("2", "02");
?????? map.put("3", "03");
?????? Set<Entry<String, String>> set = map.entrySet();
??????
?????? Iterator<Entry<String, String>> it = set.iterator();
?????? while(it.hasNext())
?????? {
?????????? System.out.println(it.next().getKey());
?????????? System.out.println(it.next().getValue());
?????? }
??? }
Collections:专门用于对集合进行操作的工具类
Sort，参数中的集合里的对象所属的类必须具有比较性，也就是继承compareable类
Max
BinarySearch：必须是有序集合，只要返回是负数就是不存在
Fill：将集合中的元素全部替换局限性，
Reverse：反转顺序
Reverseorder：
Swap:置换位置
Shuffle：随机置换位置
Arrays:用于操作数组的工具类
binarySearch：二分法查找
deepEquals：深层次比
equals：只比较数组
fill：替换
sort：甚至可以进行局部排序
toString：
asList：将数组转换成list 好处：可以使用集合的思想和方法来操作数组元素??
注意：将数组转换成集合，不可以使用集合的增删方法，因为长度固定
集合变数组：为什么要集合变数组，是为了限定对元素的操作