JAVA零基础小白学习免费教程day13-Collection&数据结构

import java.util.ArrayList;
import java.util.Collection;
public class Demo1Collection {
    public static void main(String[] args) {
        // 创建集合对象 
        // 使用多态形式
        Collection<String> coll = new ArrayList<String>();
        // 使用方法
        // 添加功能  boolean  add(String s)
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        System.out.println(coll);
        // boolean contains(E e) 判断o是否在集合中存在
        System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));
        //boolean remove(E e) 删除在集合中的o元素
        System.out.println("删除石破天："+coll.remove("石破天"));
        System.out.println("操作之后集合中元素:"+coll);
        // size() 集合中有几个元素
        System.out.println("集合中有"+coll.size()+"个元素");
        // Object[] toArray()转换成一个Object数组
        Object[] objects = coll.toArray();
        // 遍历数组
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        // void  clear() 清空集合
        coll.clear();
        System.out.println("集合中内容为："+coll);
        
        // boolean  isEmpty()  判断是否为空
        System.out.println(coll.isEmpty());   
    }
}

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

public class IteratorDemo {
    public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();
        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
    }
}

for(元素的数据类型  变量 : Collection集合or数组的变量名){ 
    //写操作代码
}

public class NBForDemo1 {
    public static void main(String[] args) {
    int[] arr = {3,5,6,87};
        //使用增强for遍历数组
    for(int a : arr){//a代表数组中的每个元素
      System.out.println(a);
    }        
        //数组的另一种遍历方式（jdk8以上才能使用）
        Arrays.stream(str).forEach(System.out::println);
  }
}

public class NBForDemo2 {
    public static void main(String[] args) {        
      Collection<String> coll = new ArrayList<String>();
      coll.add("小河神");
      coll.add("老河神");
      coll.add("神婆");
      //使用增强for遍历
      for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
        System.out.println(s);
      }        
        //集合的另一种遍历方式（jdk8以上才能使用）
        con.forEach(System.out::println);
  }
}

public class ListDemo {
    public static void main(String[] args) {
    // 创建List集合对象
      List<String> list = new ArrayList<String>();      
      // 往 尾部添加 指定元素
      list.add("图图");
      list.add("小美");
      list.add("不高兴");
      System.out.println(list);
        
      // add(int index,String s) 往指定位置添加
      list.add(1,"没头脑");
      
      System.out.println(list);
      // String remove(int index) 删除指定位置元素  返回被删除元素
      // 删除索引位置为2的元素 
      System.out.println("删除索引位置为2的元素");
      System.out.println(list.remove(2));
      
      System.out.println(list);
      
      // String set(int index,String s)
      // 在指定位置 进行 元素替代（改） 
      // 修改指定位置元素
      list.set(0, "三毛");
      System.out.println(list);     
        //获取集合的元素个数
        int size = list.size();
        System.out.println(size);
        //根索引来获取元素 
        // String get(int index)  获取指定位置元素
        String s = list.get(0);
        System.out.println(s);      
      // 跟size() 方法一起用  来 遍历的 
      for(int i = 0;i<list.size();i++){
        System.out.println(list.get(i));
      }        
      //还可以使用增强for
      for (String string : list) {
      System.out.println(string);
    }   
  }
}

List的实现类特点：
      ArrayList:
        底层数据结构是数组，查询快，增删慢
        线程不安全，效率高
      LinkedList:
        底层数据结构是链表，查询慢，增删快
        线程不安全，效率高
      Vector:
        底层数据结构是数组，查询快，增删慢
        线程安全，效率低

ArrayList:
    底层数据结构是数组，查询快，增删慢
    线程不安全，效率高

/ 
   ArrayList 存储自定义对象并遍历
  /
public class ArrayListDemo2 {
  public static void main(String[] args) { 
        List<Student> list = new ArrayList<>();
        Student s1 = new Student();
        s1.setId(11);
        s1.setName("小包面");
        Student s2 = new Student();
        s2.setId(22);
        s2.setName("小肉丝");
        list.add(s1);
        list.add(s2);
        System.out.println(list);
        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            //注意返回的类型为是Student对象
            Student stu = it.next();
            System.out.println(stu.getId());
            System.out.println(stu.getName());
        }
        System.out.println("=====================");
        for (Student s : list){
            System.out.println(s.getName()+": "+s.getId());
        }
        System.out.println("=====================");
        for(int x = 0; x < list.size(); x++){
            Student stu = list.get(x);
            System.out.println(stu.getId()+": "+stu.getName());
        }
  }
}

LinkedList:
  底层数据结构是链表，查询慢，增删快
  线程不安全，效率高

/*
 * LinkedList的特有功能：
 *    A:添加功能
 *      public void addFirst(Object e)
 *      public void addLast(Object e)
 *    B:获取功能
 *      public Object getFirst()
 *      public Obejct getLast()
 *    C:删除功能
 *      public Object removeFirst()
 *      public Object removeLast()
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        // 添加元素
    link.add("hello");
    link.add("world");
    link.add("java");        
        //添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);        
        // 获取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());        
        // 删除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());
        while (!link.isEmpty()) { //判断集合是否为空
            System.out.println(link.pop()); 
        }
        System.out.println(link);
    }
}

Vector:
        底层数据结构是数组，查询快，增删慢
        线程安全，效率低

/*
 * Vector：
   vector是list的实现类，list中所有方法vector都可以使用，这里就介绍vector特有方法
 * 1：添加功能
 *    public void addElement(Object obj)    --  add()
 * 2：获取功能
 *    public Object elementAt(int index)    --  get()
 *    public Enumeration elements()     --  Iterator iterator()
 *        boolean hasMoreElements()   --    hasNext()
 *        Object nextElement()        --  next()
*/
public class VectorDemo {
  public static void main(String[] args) {
    // 创建集合对象
    Vector v = new Vector();
    // 添加功能
    v.addElement("hello");
    v.addElement("world");
    v.addElement("java");
    // 遍历
    for (int x = 0; x < v.size(); x++) {
      String s = (String) v.elementAt(x);
      System.out.println(s);
    }
    System.out.println("------------------");
    //了解
    Enumeration en = v.elements(); // 返回的是实现类的对象
    while (en.hasMoreElements()) {
      String s = (String) en.nextElement();
      System.out.println(s);
    }
  }
}

List的子类特点：
      ArrayList:
        底层数据结构是数组，查询快，增删慢
        线程不安全，效率高
      LinkedList:
        底层数据结构是链表，查询慢，增删快
        线程不安全，效率高
      Vector:
        底层数据结构是数组，查询快，增删慢
        线程安全，效率低
 
 list集合特点：有序可重复
 
 今后我们如何选择list的三个子类？
  如果你想查询快：选ArrayListVector
  如果你想增删快：选LinkedList
  如果你想要效率高：选ArrayList，LinkedList
  如果你想要效率低：选Vector
  如果你想要线程安全：选Vector
  如果你想要线程不安全：选ArrayList，LinkedList
  
以上都是分业务情况来决定你要用哪一个集合。如果你实在不知道该如何选择，你就选译：ArrayList