2021-07-09

java基础（四）

1.Conlection

1.1 add()

​ 表示添加元素方法

1.2 size()

​ 表示集合中已有元素的个数

1.3 isEmpty()

​ 判断集合是否为空集，为空返回true，否则返回false

1.4 clear()

​ 清空当前集合

1.5 contains(E e)

用集合的equals方法判断元素e元素是否在集合里，有就返回true,否则返回false；

没有重写的equals是使用的“==”比较，重写equals方法

public boolean equals(Object obj){

​ if(obj==null){

​ return false;

​ }

​ if(obj==this){

​ return true;

​ }

​ if(obj instanceof Point){

​ Point p =(Point)obj;

​ return p;

​ }

​ return false;

}

1.6 toString方法

​ 会将每个元素的toString体现出来

• 集合只能存放引用类型元素，并且存放的也是元素的引用（地址），八大基本类型要转成包装类。

当集合中引用所指的对象的属性发生改变时，集合中存放的元素也会发生改变，因为集合中存的是地址，是根据地址去找对象的。

1.7 remove

删除元素，根据重写equals比较，看是否有该元素存在，存在就删除，返回true,不存在就删除失败返回false,只删一个元素。

1.8 addAll(Conllection c)

并集，要求将另一个集合的全部元素，添加到使用该方法的集合对象上面去。并不要求这两个集合对象是同类型。会因集合对象的不同，addAll方法的操作也不相同。

当HashSet集合对象(无序，唯一)调用addAll方法时，里面的值都只会出现一次，如果从addAll()方法的参数对象中有元素已经存在HashSet集合对象中，就不会将该元素添加到HashSet对象中。如果是ArrayList集合对象（有序，不唯一），则会将addAll方法参数对象的所有元素添加到ArrayList集合对象里。

1.9 ContainsAll()

c2.containsAll(c3)集合对象c3是否是c2的真子集，是则返回true,否则返回false

2.0 removeAll()

删交集,保留除交集以外，自己剩余的元素

• 遍历集合元素：iterator迭代器，迭代器接口都定义了一个关于遍历集合元素的操作方法，每个集合都实现了迭代器实现类。

Iterator it = c.iterator();

while(it.hasNext()){

​ String o = (String) it.next(); //取之前要用instance of判断是否是String类型，不是则类型转换

}

在使用迭代器遍历的过程中，不允许用集合的方式进行增、删、改操作，否则会抛异常，因为迭代器会发现集合发生了改变，就会抛异常，可以使用 it.remove()删除元素

• JDK5推出了一个新特性 增强for循环 ，称为“新循环"，

新循环遍历数组是编译器能识别的，但虚拟机不能，所以在编译器会将新循环转为传统的for循环遍历数组的方式，所以虚拟机能识别到。

新循环遍历集合时，编译器会将新循环转为迭代器遍历集合的方式，所以在遍历过程中不能使用集合的增删操作，否则会抛出异常报错。

2.泛型

允许将一个类中属性的类型，方法参数的类型以及方法返回值类型等定义权移交给使用者。这使得实际应用中使用这个类更加灵活便捷。

3.集合和数组进行转换

• 集合转数组，集合提供了toArray方法

  package list;
  
  import java.util.*;
  
  public class GetSetDemo {
  	
  	public static void main(String [] args) {
  		
  		Collection<String> c=new ArrayList<String>();
  		c.add("1");
  		c.add("2");
  		c.add("3");
  		c.add("4");
  		System.out.println(c);
  		
  		//Object[] array=c.toArray();    //jdk 1.5之前
  		
  		String [] array
  		       =c.toArray(new String[c.size()]);
  	
  	}
  
  }
  
  

• 数组转集合

  package list;
  
  import java.util.*;
  
  public class GetSetDemo {
  	
  	public static void main(String [] args) {
  	
  		String [] array= {"1","2","3","4","5"};
  		
  		List<String> list=Arrays.asList(array);
  	
  		System.out.println(list);
          //注意，如果你这个集合是通过数组转过来的，改变集合元素，也同样会改变数组里的元素
  	}
  
  }
  
  

  小结：1.数组转换的集合对其元素操作就是对原数组对应元素的操作

  ​ 2.由于数组是定长的，所以不支持集合的增删操作，下面的操作会抛出异常

  ​ 3.所有的集合都提供了一个参数为Collection的构造方法，作用是在创建当前集合的同时包含给定集合中的所有元素

• 集合工具类: java.util.Conllections

  小结：

  • 工具类提供了一个静态方法：sort ,可以对List集合进行自然排序（从小到大）

    package list;
    
    import java.util.*;
    
    public class GetSetDemo {
    	
    	public static void main(String [] args) {
    	
    	   List<Integer> list
    	           =new ArrayList<Integer>();
    	   list.add(2);
    	   list.add(324);
    	   list.add(1);
    	   list.add(100);
    	   
    	   System.out.println(list.toString());   //[2, 324, 1, 100]
    	    
    	   Collections.sort(list);
    
    	   System.out.println(list); //[1, 2, 100, 324]
    	   
    	}
    }
    
    

  • Collections的sort方法排序的集合要求必须实现Comparable接口

    package cn.sxt.conllection;
    
    public class Point {
    
    	
    	/*
    	 * 当一个类实现了Comparable接口的后必须重写方法：compareTo
    	 * 该方法的作用是比较当前对象this与方法的
    	 * 参数对象o之间的大小。
    	 * 
    	 * 返回值不关心具体取值，只关心取值范围
    	 * 但返回值>0:当前对象大于参数对象（this>o）
    	 * 但返回值<0：当前对象小于参数对象
    	 * 但返回值=0：两个对象相等
    	 */
    	public int compareTo(Point o) {
    		 int len=this.x*this*x+this.y*this.y;
             int olen=o.x*o.x+o.y*o.y;
            return len-olen;
    	}
    }
    
    

  • 包装类（String,很多java API中的类已经实现了该接口）元素的集合已经实现过Comparable接口，并重写了compareTo方法，可以直接使用sort方法就行了；而自定义类就不行，需要实现Comparable接口，并重写compareTo方法，如果是这种情况，就建议不要使用sort了，因为如果使用sort就意味着要实现接口重写方法，需要改代码，这就会导致侵入性。

  • String 已经实现了Comparable接口

    比较规则为按照每个字符的unicode编码比较

    对于排序中文时，没有什么意义。

    对此，该sort方法的使用相对局限。

    所以当：

    排序自定义类型元素或java提供的已经实现过

    Comparable接口的元素，当时比较方法不满足我们排序需求

    时，都不应当使用sort方法。

  • 最终排序推荐：

    使用sort的重载方法，把自定义规则的比较器作为参数

    传入sort方法，这样就尽可能减少了侵入性。

4.Collection子接口

4.1 List

元素可重复，有序，提供了可以通过下标操作元素的方法，继承Collection。

• ArrayList：动态数组：遍历快，但增、删慢
• LinkedList: 链表：增、删快（尤其是首尾增删快），但遍历慢
• get(int index)
• E set(int index,E e)
• add
• size
• void add(int index, E e)
• E remove(int index)
• List subList( [int start, int end) ) //取子集合，对子集合删除，就是对原集合里面的元素进行删除
• clear()

​

4.2 set

不可重复，无序，通过元素自身的equals方法来比较。

5.队列（先进先出）

• java.util.Queue；

  Queue接口继承自Collection；

  队列也可以保存一组元素，但是存取元素必须遵循先进先出模式，常用实现类：LinkedList。

• offer是入队操作，向队列末尾追加元素

• **poll方法是出队操作，**获取队首元素后该元素即从队列中被删除

• peek是引用队首元素，元素不做出队操作

• 遍历队列，使用迭代器遍历，元素不会因此被队列删除

6.栈（先进后出,实现后退和前进）

• 双端队列；

  java.util.Deque接口

  Deque继承自Queue接口

  双端队列是指队列两端都可以做进出队操作。

  常用实现类：LinkedList

7. 集合并发安全问题

• 集合有线程安全的实现。我们可以借助Collection将现有的集合转换为一个线程安全的。

• List中常用的实现类：ArrayList，LinkedList它们都不是线程安全的。

• 将给定的集合转换为一个线程安全的集合

  List list = Collections.synchronizedList(list);
  

• HashSet同样也不是线程安全的

  //将list集合元素添加到set集合里
  Set<String> set
      =new   HashSet<String>(list);
  set = Collections.synchronizedSet(set);
      
  

• 队列也有并发安全的实现

  • 阻塞队列 BlockingQueue ，BlockingDeque

    阻塞队列内部使用双缓冲实现，在保证并发安全的前提下解决了存取互斥问题，所以并发效率更好。

BlockingQueue<String>  queue
    = new LinkedBlockingQueue<String> ();

8 .HashMap

[]: https://blog.csdn.net/qq_27665897/article/details/90810402?spm=1001.2014.3001.5501