集合框架2

1、ArrayList去除重复字符串

      思路：创建一个新的集合，然后将旧集合的内容遍历放入新集合，如果新集合里不存在该元素就放入，存在就不要了

1. publicstaticvoid main (String[] args){
2. ArrayList list=newArrayList();
3. list.add("a");
4. list.add("a");
5. list.add("b");
6. list.add("b");
7. list.add("c");
8. list.add("d");
9. ArrayList newList=getSingle(list);
10. System.out.println(newList);
11. }
13. /**
14. * 创建新集合将重复元素去掉
15. * 1、明确返回值类型，返回ArrayList
16. * 2、明确参数列表ArrayList
17. */
19. publicstaticArrayList getSingle(ArrayList list){
20. ArrayList newList =newArrayList();
21. Iterator it = list.iterator();
22. while(it.hasNext()){
23. Object obj = it.next();
24. if(!newList.contains(obj)){
25. newList.add(obj);
26. }
27. }
28. return newList;
29. }
30. }

 

2、ArrayList去除重复的自定义对象

contains依赖于equals方法，所以需要在person类中重写equals方法

  

 

    注意：remove方法的底层同样依赖于equals方法：

 

3、LinkedList特有功能

 

4、栈和队列

    栈：先进后出

           

 

    队列：先进先出

          

 

5、LinkedList模拟栈数据结构的集合并测试  

1. publicclassStack{
3. privateLinkedList list =newLinkedList();
4. // 模拟进栈方法
6. publicvoid in(Object obj){
7. list.addLast(obj);
8. }
10. // 模拟出栈方法
11. publicObject out(){
12. return list.removeLast();
13. }
15. // 模拟栈结构是否为空
16. publicboolean isEmpty(){
17. return list.isEmpty();
18. }
20. }

1. publicstaticvoid main(String[] args){
2. //demo1();
3. Stack s=newStack();
4. s.in("a");
5. s.in("b");
6. s.in("c");
7. s.in("d");
8. while(!s.isEmpty()){
9. System.out.println(s.out());
10. }
11. }

 

6、泛型概述和基本使用

 

 <>标识了集合只能存储某该类引用数据或者该类的子类型，所有对象都继承object，泛型不定义为object，无意义

 

 类型转换异常：将类型转换成非该类型实例时出现类型转换异常：运行期错误

 

 注意：it.next()只能调用一次，如果多次会让指针向后移动多次

 

泛型注意事项：

 

7、泛型的由来

 种瓜得瓜种豆得豆

 

8、泛型类的概述及其使用

 

 

9、泛型方法的概述和使用

     非静态方法：方法泛型需要与类的泛型一致；如果不一致，需要在方法上声明该泛型：

 

 

      静态方法：必须声明自己的泛型，因为静态方法是随着类的加载而加载的，非静态方法是在创建对象的时候赋值

 

10、泛型接口的使用

两种方法：推荐用第一种

       

 

 

11、泛型高级之通配符

 

 

 

12、增强for循环的概述和使用

底层依赖的是迭代器iterator

 

 

 

13、三种迭代的能否删除

 

1. publicstaticvoid main(String[] args){
2. // TODO Auto-generated method stub
3. ArrayList<String> list=newArrayList<>();
4. list.add("a");
5. list.add("b");
6. list.add("b");
7. list.add("c");
8. list.add("d");
9. //1、普通for循环版删除
10. for(int i=0;i<list.size();i++){
11. if("b".equals(list.get(i))){
12. list.remove(i--);
13. }
14. }
15. System.out.println(list);
16. }

1. //2、迭代器删除
2. Iterator<String> it=list.iterator();
3. while(it.hasNext()){
4. if("b".equals(it.next())){
5. //list.remove("b");不能用集合的删除方法，迭代过程中如果修改会出现【并发修改异常】
6. it.remove();
7. }
8. }
9. System.out.println(list);
10. }

1. //3、增强for循环,不能删除，只能遍历，因为底层由迭代器实现的
2. for(String string:list){
3. if("b".equals(string)){
4. list.remove("b");
5. }
6. }
7. System.out.println(list);
8. }

 

14、静态导入的概述和使用

 静态导入后，Arrays.sort的前缀可以省略不写直接写sort

 

15、可变参数的概述和使用

 

1. publicclassChangeableArgs_Demo2{
3. publicstaticvoid main(String[] args){
4. // TODO Auto-generated method stub
5. int[] arr={11,22,33,44,55};
6. //print(arr);
7. print(11,22,33);
8. }
10. // public static void print(int[] arr){
11. // for(int i=0;i<arr.length;i++){
12. // System.out.println(arr[i]);
13. // }
14. // }
16. publicstaticvoid print(int...arr){//可变参数是一个数组
17. for(int i=0;i<arr.length;i++){
18. System.out.println(arr[i]);
19. }
20. }
22. }

 

16、Arrays工具类的aslist方法的使用

1. publicstaticvoid main(String[] args){
2. //demo1();
3. //demo2();
4. //集合转数组，加泛型的
5. ArrayList<String> list=newArrayList<>();
6. list.add("a");
7. list.add("b");
8. list.add("c");
9. list.add("d");
10. list.add("e");
12. String[] arr = list.toArray(newString[6]);//当集合转换数组时，数组的长度如果是<=集合的size值，转换后的数组长度等于集合
13. //如果数组的长度>集合的size值，那分配的数组长度就和指定的长度相同
14. for(int i=0;i<arr.length;i++){
15. System.out.println(arr[i]);
16. }
18. }
20. publicstaticvoid demo2(){
21. // int[] arr={11,22,33,44,55}; 基本数据类型的数组转换成集合，会将整个数组当做一个对象进行转换
22. // List<int[]> list=Arrays.asList(arr);
23. // System.out.println(list);
24. Integer[] arr={11,22,33};//想将数组转换成集合，数组必须是引用数据类型
25. List<Integer> list=Arrays.asList(arr);
26. System.out.println(list);
27. }
29. publicstaticvoid demo1(){
30. String[] arr={"a","b","c"};
31. List<String> list=Arrays.asList(arr);//将数组转换成集合
32. //list.add("d"); 不能添加
33. System.out.println(list);
34. }

 

17、ArrayList嵌套

1. publicclassArrayListArrayList_demo1{
2. /**
3. * 集合嵌套
4. * 学科分为若干个班级
5. * 整个学科是一个大集合
6. * 若干个班级分为每一个小集合
7. * @param args
8. */
9. publicstaticvoid main(String[] args){
10. ArrayList<ArrayList<Person>> list=newArrayList<>();
12. ArrayList<Person> first =newArrayList<>();
13. first.add(newPerson("张三",23));
14. first.add(newPerson("李四",24));
15. first.add(newPerson("王五",25));
17. ArrayList<Person> second =newArrayList<>();
18. second.add(newPerson("大黄",3));
19. second.add(newPerson("豆豆",4));
20. second.add(newPerson("小呆",5));
22. //将班级添加到学科集合中
23. list.add(first);
24. list.add(second);
26. //遍历学科集合
27. for(ArrayList<Person>a : list){
28. for(Person p:a){
29. System.out.println(p);
30. }
31. }
32. }
33. }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

来自为知笔记(Wiz)