java集合与泛型

集合和数组的区别

1. 长度区别&＃xff1a;数组固定集合可变
2. 内容区别&＃xff1a;数组可以是基本类型&＃xff0c;也可以是引用类型集合只能是引用类型
3. 元素内容&＃xff1a;数组只能存储同一种类型集合可以存储不同类型(其实集合一般存储的也是同一种类型)


继承体系结构

Collection|--List|--ArrayList|--Vector|--LinkedList|--Set|--HashSet|--TreeSet


案例&＃xff1a;迭代器遍历方式

public static void main(String[] args) {Collection c &＃61; new ArrayList();c.add("java");c.add("scala");c.add("hadoop");//遍历集合Iterator it &＃61; c.iterator();while(it.hasNext()) {String s &＃61;(String) it.next();System.out.println(s);}
}

List

特点&＃xff1a;

有序(存储顺序和取出顺序一致)&＃xff0c;可重复。


特有遍历&＃xff1a;由size()和get()结合

List list &＃61; new ArrayList();
list.add("java");
list.add("scala");
list.add("hadoop");
//遍历集合
Iterator it &＃61; list.iterator();
while(it.hasNext()) {String s &＃61;(String) it.next();System.out.println(s);
}
for(int x&＃61;0; x<list.size(); x&＃43;&＃43;) {String s &＃61;(String) list.get(x);System.out.println(s);
}

常见数据结构

ArrayXxx:底层数据结构是数组&＃xff0c;查询快&＃xff0c;增删慢
LinkedXxx:底层数据结构是链表&＃xff0c;查询慢&＃xff0c;增删快
HashXxx:底层数据结构是哈希表。依赖两个方法&＃xff1a;hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序&＃xff1a;自然排序和比较器排序


List的子类特点

ArrayList底层数据结构是数组&＃xff0c;查询快&＃xff0c;增删慢。线程不安全&＃xff0c;效率高。
Vector&＃xff08;几乎不用&＃xff09;底层数据结构是数组&＃xff0c;查询快&＃xff0c;增删慢。线程安全&＃xff0c;效率低。
LinkedList底层数据结构是链表&＃xff0c;查询慢&＃xff0c;增删快。线程不安全&＃xff0c;效率高。有特有功能&＃xff1a;a:添加addFirst()addLast()b:删除removeFirst()removeLast()c:获取getFirst()getLast()


Set

特点

无序,唯一(由hashCode()和equals()保证)


HashSet

A:底层数据结构是哈希表(是一个元素为链表的数组)B:哈希表底层依赖两个方法&＃xff1a;hashCode()和equals()执行顺序&＃xff1a;首先比较哈希值是否相同相同&＃xff1a;继续执行equals()方法返回true&＃xff1a;元素重复了&＃xff0c;不添加返回false&＃xff1a;直接把元素添加到集合不同&＃xff1a;就直接把元素添加到集合


TreeSet集合

A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式a:自然排序(元素具备比较性)让元素所属的类实现Comparable接口b:比较器排序(集合具备比较性)让集合构造方法接收Comparator的实现类对象


Collection集合总结

Collection|--List 有序,可重复|--ArrayList底层数据结构是数组&＃xff0c;查询快&＃xff0c;增删慢。线程不安全&＃xff0c;效率高|--Vector底层数据结构是数组&＃xff0c;查询快&＃xff0c;增删慢。线程安全&＃xff0c;效率低|--LinkedList底层数据结构是链表&＃xff0c;查询慢&＃xff0c;增删快。线程不安全&＃xff0c;效率高|--Set 无序,唯一|--HashSet底层数据结构是哈希表。唯一性依赖两个方法&＃xff1a;hashCode()和equals()开发中自动生成这两个方法即可|--LinkedHashSet底层数据结构是链表和哈希表由链表保证元素有序由哈希表保证元素唯一|--TreeSet底层数据结构是红黑树排序&＃xff1a;自然排序比较器排序唯一性&＃xff1a;根据比较的返回值是否是0来决定


Collection集合使用谁?

唯一吗?是&＃xff1a;Set排序吗?是&＃xff1a;TreeSet否&＃xff1a;HashSet否&＃xff1a;List要安全吗?是&＃xff1a;Vector(几乎不用)否&＃xff1a;ArrayList或者LinkedList查询多&＃xff1a;ArrayList增删多&＃xff1a;LinkedList


泛型

是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

特点&＃xff1a;

1. 把运行时期的问题提前到了编译期间
2. 避免了强制类型转换
3. 优化了程序设计&＃xff0c;解决了黄色警告线问题&＃xff0c;让程序更安全


高级通配符

? 表示任意的类型都是可以的
? extends E 向下限定&＃xff0c;E及其子类
? super E 向上限定&＃xff0c;E极其父类


遍历&＃xff1a;

// JDK7的新特性&＃xff1a;泛型推断。
// ArrayList array &＃61; new ArrayList<>();
// 不建议
ArrayList array &＃61; new ArrayList();Student s1 &＃61; new Student("java", 40);
Student s2 &＃61; new Student("scala", 10);
Student s3 &＃61; new Student("hadoop", 5);array.add(s1);
array.add(s2);
array.add(s3);
// 遍历
Iterator it &＃61; array.iterator();
while (it.hasNext()) {Student s &＃61; it.next();
}
for (int x &＃61; 0; x <array.size(); x&＃43;&＃43;) {Student s &＃61; array.get(x);
}

增强for循环

格式&＃xff1a;

for(数据类型 变量名 : 数组或者Collection集合的对象) {使用该变量即可&＃xff0c;该变量其实就是数组或者集合中的元素。
}


好处

简化了数组和集合的遍历


弊端

增强for循环的目标不能为null。建议在使用前&＃xff0c;先判断是否为null。


示例&＃xff1a;

HashSet ts &＃61; new HashSet();
while (ts.size() <10) {ts.add(ts.size());
}for (Integer i : ts) {System.out.println(i);
}

案例&＃xff1a;获取10个1至20的随机数&＃xff0c;要求随机数不能重复

public static void main(String[] args) {// 创建随机数对象Random r &＃61; new Random();// 创建一个Set集合HashSet ts &＃61; new HashSet();// 判断集合的长度是不是小于10while (ts.size() <10) {int num &＃61; r.nextInt(20) &＃43; 1;ts.add(num);}// 遍历Set集合for (Integer i : ts) {System.out.println(i);}
}

案例&＃xff1a;”aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public static void main(String[] args) {// 定义一个字符串(可以改进为键盘录入)Scanner sc &＃61; new Scanner(System.in);System.out.println("请输入一个字符串&＃xff1a;");String line &＃61; sc.nextLine();// 定义一个TreeMap集合TreeMap tm &＃61; new TreeMap();//把字符串转换为字符数组char[] chs &＃61; line.toCharArray();//遍历字符数组&＃xff0c;得到每一个字符for(char ch : chs){//拿刚才得到的字符作为键到集合中去找值&＃xff0c;看返回值Integer i &＃61; tm.get(ch);//是null:说明该键不存在&＃xff0c;就把该字符作为键&＃xff0c;1作为值存储if(i &＃61;&＃61; null){tm.put(ch, 1);}else {//不是null:说明该键存在&＃xff0c;就把值加1&＃xff0c;然后重写存储该键和值i&＃43;&＃43;;tm.put(ch,i);}}//定义字符串缓冲区变量StringBuilder sb&＃61; new StringBuilder();//遍历集合&＃xff0c;得到键和值&＃xff0c;进行按照要求拼接Set set &＃61; tm.keySet();for(Character key : set){Integer value &＃61; tm.get(key);sb.append(key).append("(").append(value).append(")");}//把字符串缓冲区转换为字符串输出String result &＃61; sb.toString();System.out.println("result:"&＃43;result);}