首页 > 其他分享> > 达内培训Week2 集合01 8.24

达内培训Week2 集合01 8.24

2022-08-24 19:06:11 作者：互联网

集合01 8.24

什么是集合：
- 集合和数组类似，可以保存一组元素，并且提供了操作数组元素的方法，使用方便。
Java集合框架接口
- Java.util.Collection接口：所有结合的接口，封装了所有集合共有的内容。下面有多个实现类，有更多的数据结构可以选择。
- Collection接口下面还有常见的子接口：
  - List ，线性表，可以重复集合
  - Set ，不可重复，无序
  - Map，键值对K-V
常见操作
- add():
- size():
- isEmpty():
- clear():
- contains():
- remove()：从集合中删除给定元素，成功删除返回true.
- addAll()：将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回true
- containsAll()：判断当前集合中是否包含参数集合中的所有元素
- retainAll()：取交集
- removeAll()：删交集
集合的遍历：
- Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。
- java.util.Iterator接口：定义了迭代器遍历集合的相关操作。不同的集合都实现了用于遍历自身元素的迭代器实现类，我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。
- 迭代器遍历遵循的步骤为：问、取、删，其中删除元素并不是必要操作
- JDK1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合和数组。
- 语法：
```
for(元素类型 变量名 : 集合或数组){
    循环体
}
```
由于集合没有下标，需要用迭代器来遍历

迭代器操作：问，取，删除

快捷键itit

增强for循环，jdk1.5以后的新功能

语法： for（元素类型变量名：数组或集合）{

循环体
泛型
- jdk1.5的新特性：泛型
- 泛型也是参数化类型。允许我们在使用类中指定它当中的属性和方法、参数或返回值，使得使用更加方便。
  - 泛型在集合中被广泛使用

集合与数组的转换：

数组转换为List集合：
List集合转为数组：

package com.mlyStudyJava.collection_;

import java.util.Objects;

public class Point {
    private int x;
    private int y;
//构造方法，构造方法器是与类名一致。
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 //toString 从地址->数值

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }


    //get set x,y
    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class Collection01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        boolean b = c.add("six");
        System.out.println(c);//Collection重写了Object的toString方法

        int size = c.size();
        System.out.println("size:"+size);

        boolean isEmpty = c.isEmpty();
        System.out.println("是否是空集：" +isEmpty);
        c.clear();
        System.out.println(c);
        System.out.println("size:"+c.size());
        System.out.println("是否为空集："+c.isEmpty());
    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;

public class Collection02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Point(1,2));
        c.add(new Point(3,4));
        c.add(new Point(5,6));
        c.add(new Point(7,8));
        c.add(new Point(9,0));
        c.add(new Point(1,2));
        //集合 的 Point重写了Object的toString()方法
        //前提是要在Point中先重写，如果不重写也不行，输出就是内存地址
        //[元素1.toString(),元素2.toString(), ....]
        System.out.println(c);


    }


}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;

public class Collection03 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Point(1,2));
        c.add(new Point(3,4));
        c.add(new Point(5,6));
        c.add(new Point(7,8));
        c.add(new Point(9,0));
        c.add(new Point(1,2));
        final Point p = new Point(1, 2);
        //判断c中是否包含p，判断依据是p是否与集合元素存在equals为true的情况
        //当point重写equals后就会变T 因为equals比较值,不然还是F原来比较对象地址
        boolean contains = c.contains(p);
        System.out.println("是否包含："+contains);//F 未重写p的euqals
        System.out.println("是否包含："+contains);//T 重写后
/**
 * boolean remove ()
 * 从集合中删除给定元素equals比较true ，若存在重复元素删除
 */

        c.remove(p);
        System.out.println(c);
    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;

public class Collection04 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("c++");
        c1.add(".net");
        System.out.println(c1);//[java,c++,net]

        System.out.println("===============");
        Collection c2 = new ArrayList();
        c2.add("android");
        c2.add("ios");
        c2.add("java");
        System.out.println(c2);//[android,ios,java]
/**
 * boolean addAll(Collection c)
 * 将参数给定的集合中所有的元素添加到当前集合，添加后当前集合后发生改变返回
 */
        c1.addAll(c2);
        System.out.println("c1:"+c1);
        System.out.println("c2:"+c2);
        System.out.println("==================");
        Collection c3 = new ArrayList();
        c3.add("c++");
        c3.add("android");
        c3.add("php");
        System.out.println("c3:"+c3); //[c++,android,php]

        /**
         * boolean containsAlL(Collection c)
         * 判断集合中是否包含参数的所有集合
         */

        boolean contains = c1.containsAll(c3);//判断c1中是否包含c3
        System.out.println("是否包含所有："+contains);

        System.out.println("====================");
        //取交集 c1中仅保留c1与c3的共有元素，c3不变
//        c1.retainAll(c3);
//
//        System.out.println("c1:"+c1);
//        System.out.println("c3:"+c3);
//        System.out.println("====================");
        c1.removeAll(c3);
        System.out.println("c1:"+c1);
        System.out.println("c3:"+c3);


    }



}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;

public class Collection05 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Point p = new Point(1, 2);
        c.add(p);
        System.out.println("p:" + p); //(1,2)
        System.out.println("c:" + c);//[(1,2),(3,4)]

    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/*
集合转换成数组
Collection->toArray可以将当前集合转换为数组
 */
public class CollectionToArray01 {
    public static void main(String[] args) {
        Collection<String > c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);
        System.out.println("=========================");
        String[] array = c.toArray(new String[8]);
        /**
         * 若参数的数组元素=集合元素个数，就正常转换
         * 若参数的数组元素>集合元素个数，就正常转换，同时末尾补默认值
         * 若参数的数组元素<集合元素个数，就会按照集合大小给数组
         */
        System.out.println(Arrays.toString(array));
    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {

       Collection<String> c = new ArrayList<>();
       c.add("one");
       c.add("two");
       c.add("three");
       //c.add(123);//编译错误，参数类型违背了集合c所指定的泛型E，应该是String
        Iterator<String> it =c.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
        System.out.println("==============");
        for(String str:c){
            System.out.println(str);
        }

    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 集合的遍历：
 */
public class Iterator01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add("four");
        c.add("#");
        c.add("five");
        System.out.println(c); //[one, #, two, #, three, #, four, #, five]
    /*
    迭代器的常用方法
    1.boolean hasNext()    -----问
    询问集合是否还有“下一个”元素可供迭代
    注意：迭代器默认开始位置是在初始位置之前 -1的位置 应该是指针
    无论调用多少次hasNext()方法，迭代器的位置都不会变
    2.Object next()-------------取
    迭代器向后移动一个位置来指向集合的下一个元素并将其获取

     */

        Iterator it =c.iterator();//获取集合c的迭代器 c.iterator.var
        while (it.hasNext()) {//若有下一个元素
            String str =(String)it.next();//获取下一个元素
           if("#".equals(str)){
               //c.remove(str);集合的长度不能变
               it.remove();//删除所取的元素
           }

            System.out.println(str);
        }
        System.out.println(c);

    }
}

package com.mlyStudyJava.collection_;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class NewFor {
    public static void main(String[] args) {
        String[] array ={"one","two","three","four","five"};
        for (int i = 0; i <array.length ; i++) {
           // String str = array[i];
            System.out.println(array[i]);

        }
        System.out.println("================");
        Collection c =new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object next =  it.next();
            System.out.println(next);

        }
        System.out.println("================");
        //新的for循环遍历数组
        for(String str :array){
            System.out.println(str);
        }
        System.out.println("================");
        for(Object obj :c){
            //String str=(String)obj;
            System.out.println(obj);

        }


    }
}

标签：01,java,System,8.24,集合,add,println,Week2,out
来源： https://www.cnblogs.com/maluyi/p/16621234.html