Java基础——集合框架

最新推荐文章于 2022-08-19 16:09:15 发布
最新推荐文章于 2022-08-19 16:09:15 发布
阅读量764 收藏
点赞数
分类专栏： Java基础 文章标签： java 编程 计算机 黑马程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012453500/article/details/41626257
版权

 集合框架

1.数据多了可用数组存储，对象多了可用数组或者集合存储

2.集合长度是可变的，可以存储不同类型的对象

3.实际结构中，集合存放的是对象的地址值



一. Collection接口（集合的超类）

1.其下容器底层数据结构不同，存储方式也不同 

2.集合的特殊取出方式——迭代器

方法摘要
 booleanadd(E e) 
          确保此 collection 包含指定的元素（可选操作）。
 booleanaddAll(Collection<? extends E> c) 
          将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。添加一个集合
 voidclear() 
          移除此 collection 中的所有元素（可选操作）。
 booleancontains(Object o) 
          如果此 collection 包含指定的元素，则返回 true。List集合中默认调用对象的equals()方法
 booleancontainsAll(Collection<?> c) 
          如果此 collection 包含指定 collection 中的所有元素，则返回 true。
 booleanequals(Object o) 
          比较此 collection 与指定对象是否相等。
 inthashCode() 
          返回此 collection 的哈希码值。
 booleanisEmpty() 
          如果此 collection 不包含元素，则返回 true。
 Iterator<E>iterator() 
          返回在此 collection 的元素上进行迭代的迭代器。重点方法，特殊的取出方式
 booleanremove(Object o) 
          从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。List集合中默认调用对象的equals()方法
 booleanremoveAll(Collection<?> c) 
          移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。删除交集元素
 booleanretainAll(Collection<?> c) 
          仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。只保留交集元素
 intsize() 
          返回此 collection 中的元素数。
 Object[]toArray() 
          返回包含此 collection 中所有元素的数组。（集合转换为数组是为了限定用户对元素的操作）
<T> T[]toArray(T[] a) 
          返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。（定义数组长度最好刚刚好，不然浪费内存）

Iterator接口（迭代器） 

1.知识点：每个集合类中都有一个内部类存储自己类一系列特殊的取出方法，因为每一个集合类的底层存储结构不一样。并且该内部类实现Interator接口

方法摘要
 booleanhasNext() 
          如果仍有元素可以迭代，则返回 true。
 Enext() 
          返回迭代的下一个元素。
 voidremove() 
          从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

1.List集合

重点：元素是按存入顺序存储的，元素可以重复，每个元素有索引值

特有方法摘要
 booleanadd(E e) 
          向列表的尾部添加指定的元素（可选操作）。
 voidadd(int index, E element) 
          在列表的指定位置插入指定元素（可选操作）。（增）
 booleanaddAll(int index, Collection<? extends E> c) 
          将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。（增）
 Eremove(int index) 
          移除列表中指定位置的元素（可选操作）。（删）
 Eset(int index, E element) 
          用指定元素替换列表中指定位置的元素（可选操作）。（改）
 Eget(int index) 
          返回列表中指定位置的元素。（查）
 List<E>subList(int fromIndex, int toIndex) 
          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（查）
 ListIterator<E>listIterator() 
          返回此列表元素的列表迭代器（按适当顺序）。（查，重要，List集合特有的取出方法）
 ListIterator<E>listIterator(int index) 
          返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。（查，重要，List集合特有的取出方法）
 intindexOf(Object o) 
          返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。（查）
 intlastIndexOf(Object o) 
          返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。（查）

1.1 ListIterator接口（List集合特有的迭代器，Iterator的子类）

（1）重点：Interior迭代器中当用集合方法对集合元素进行添加或者修改改操作时会抛ConcurrentModitcationException()——并发访问异常，修改异常。因为迭代器在访问集合元素，集合也在访问自己的元素不能对同一组元素进行多种同时操作。ListIterator中添加了添加或者修改改等操作来弥补父类迭代器的这个缺陷

方法摘要
 voidadd(E e) 
          将指定的元素插入列表（可选操作）。
 booleanhasNext() 
          以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
 booleanhasPrevious() 
          如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
 Enext() 
          返回列表中的下一个元素。
 intnextIndex() 
          返回对 next 的后续调用所返回元素的索引。
 Eprevious() 
          返回列表中的前一个元素。
 intpreviousIndex() 
          返回对 previous 的后续调用所返回元素的索引。
 voidremove() 
          从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
 voidset(E e) 
          用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

1.2 ArrayList类

（1）特点：数组结构，查改快，增删慢（因为有索引，插入删除会对其后的全部索引值都有影响）线程不同步。每次超过初始长度50%延长

/**
*需求：去除一个List中的重复元素（普通数据与自定义对象数据）
*思路：1.新建一个集合，把现有List集合中全部元素全部存储到新建集合中，并且去除相同元素
*	  2.当存入的时自定义对象时一定要复写该对象的equal()方法，来定义自己的比较方法，
		因为list集合的contain()方法会默认调用对象的equals方法比较。
*/
import java.util.*;

class Person//自定义人对象
{
	private String name;//姓名
	private int age;//年龄

	//初始化方式
	Person(String name,int age){//
		this.name = name;
		this.age = age;
	}

	//自定义输出方式
	public String toString(){
		return "Person("+name+"..."+age+")";
	}

	//名称的get方法
	public String getName(){
		return name;
	}

	//年龄的get方法
	public int getAge(){
		return age;
	}

	//复写的equals比较方法
	public boolean equals(Object obj){
		Person p = (Person)obj;
		return name.equals(p.getName()) && age == p.getAge();
	}
}

class java
{
	public static void main(String[] args){
		Person p1 = new Person("张三",3);
		Person p2 = new Person("李四",4);
		Person p3 = new Person("王五",5);
		Person p4 = new Person("张三",3);
		List<Person> al = Arrays.asList(p1,p2,p3,p4,p1);//重复元素集合
		System.out.println(al);
		System.out.println(delElement(al));
	}

	//删除集合中相同数据的方法
	public static <E> List<E> delElement(List<E> al){
		List<E> li = new ArrayList<E>();
		for(Iterator<E> it = al.iterator();it.hasNext();){
			E key = it.next();
			if(!li.contains(key))
				li.add(key);
		}
		return li;
	}
}

1.3 LinkedList类

（1）特点：链表结构，增删快，查改慢（因为链表是全连接起来的，前一个连后一个，查改需要从集合第一个开始遍历到查询处）线程不同步 

（2）方法简介

方法摘要
 voidaddFirst(E e) 
          将指定元素插入此列表的开头。存入后的数据顺序要注意，是加在最前，把前面的往后顶。被offerFirst()所替代，此方法与此集合的add()方法相同
 voidaddLast(E e) 
          将指定元素添加到此列表的结尾。存入后的数据顺序要注意，是加在最后，把后面的往前顶。被offerLast()所替代
 EgetFirst() 
          返回此列表的第一个元素。被peekFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
 EgetLast() 
          返回此列表的最后一个元素。被peedLast()所替代。集合为空时调用此方法会抛出NoSuchElementException
 EremoveFirst() 
          移除并返回此列表的第一个元素。获取元素，并且删除元素，被pollFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
 EremoveLast() 
          移除并返回此列表的最后一个元素。获取元素，并且删除元素，被pollFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
 booleanofferFirst(E e) 
          在此列表的开头插入指定的元素。存入后的数据顺序要注意，是加在最前，把前面的往后顶。
 booleanofferLast(E e) 
          在此列表末尾插入指定的元素。存入后的数据顺序要注意，是加在最后，把后面的往前顶。
 EpeekFirst() 
          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
 EpeekLast() 
          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
 EpollFirst() 
          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。获取元素，并且删除元素
 EpollLast() 
          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。获取元素，并且删除元素

（3）数据结构

    <1>.堆栈：先进后出，杯子

    <2>.队列：先进先出，水管

/**
*需求：设计一个堆栈和一个队列结构的对象接收数据
*思路：1.设计两个类，分别都具有enter方法和goOut方法来接收和释放数据
*	  2.可以用LinkedList实现两个类的底层数据结构
*/
import java.util.*;

class MyStack<E>//堆栈结构
{
	//内部链式存储结构
	private LinkedList<E> ll = new LinkedList<E>();
	
	//存入数据
	public void enter(E e){
		ll.offerFirst(e);
	}

	//取出数据
	public E goOut(){
		return ll.pollFirst();
	}

	public void print(){
		System.out.println(ll);
	}
}

class MyQueue<E>//队列结构
{
	//内部链式存储结构
	private LinkedList<E> ll = new LinkedList<E>();
	
	//存入数据
	public void enter(E e){
		ll.offerFirst(e);
	}

	//取出数据
	public E goOut(){
		return  ll.pollLast();
	}

	public void print(){
		System.out.println(ll);
	}
}

class java
{
	public static void main(String[] args){
		MyQueue<String> ms = new MyQueue<String>();
		ms.enter("1");
		ms.enter("2");
		ms.enter("3");
		
		ms.print();
		System.out.println("出来的"+ms.goOut());
		ms.print();
		System.out.println("出来的"+ms.goOut());
		ms.print();
		System.out.println("出来的"+ms.goOut());
		ms.print();
	}
}

1.4 Vetor类

（1）特点：数组结构，线程同步，被ArrayList替代

（2）方法简介

特殊方法摘要
Enumeration<E>elements() 
          返回此向量的组件的枚举。

（3）Enumeration接口（枚举，被Iterator接口代替）

方法摘要
 booleanhasMoreElements() 
          测试此枚举是否包含更多的元素。
 EnextElement() 
          如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

2.Set集合

特点：元素是无序的（存入和存储顺序不同）元素不可以重复。没有自己的特性方法

2.1 HashSet类

（1）特点：哈希表数据结构，线程不同步

（2）注意：判断hashcode，不同传入，相同则再判断equals，不同传入（同地址顺延），相同不传。add()、contains()、remove()都会经历这个流程

/**
*需求：向HashSet传入自定义对象
*思路：1.自定义对象需要复写hashCode和equals方法
*	  2.hashSet中的add、remove、contains方法都会判断上边的hashCode与equals
*/

import java.util.*;

class Practice
{
	public static void main(String[] args){
		HashSet<Student> hs = new HashSet<Student>();
		
		hs.add(new Student("呵呵",12));
		hs.add(new Student("丫丫",31));
		hs.add(new Student("丫丫",31));//无法传入
		hs.add(new Student("岂可修",12));
		hs.add(new Student("八嘎",31));
		hs.add(new Student("八嘎",31));//无法传入
		hs.add(new Student("大丈夫",21));
		hs.add(new Student("大丈夫",21));//无法传入
		hs.add(new Student("萌大奶",31));

		for(Iterator<Student> it = hs.iterator();it.hasNext();){
			Student s = it.next();
			System.out.println("姓名："+s.getName()+"-------年龄："+s.getAge());
		}
		
	}
}

class Student
{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}

	public String getName(){
		return name;
	}

	public int getAge(){
		return age;
	}

	//自定义对象复写hashCode方法
	public int hashCode(){
		//System.out.println(this.name+"....哈希值.....");//方便观看
		
		//对象自定义的hashCode算法
		return this.name.hashCode()+this.age*17;
	}

	public boolean equals(Object obj){
		//判断参数类型重要，不要忽视
		if(!(obj instanceof Student))
			throw new RuntimeException();
		Student s = (Student)obj;

		//System.out.println(this.name+"....等于....."+s.name);

		//对象自定义的比较方法
		return this.name.equals(s.name) && this.age == s.age;
	}
}

2.2 TreeSet类

（1）特点：底层是二叉树数据结构，线程不同步

（2）注意：可以对Set集合中的元素进行排序，对于自定义对象的排序需要自定义排序方式，使其具备比较性。

（3）使其具备比较性的方法1：实现Comparable接口（让元素具备比较性）

Comparable（接口）

方法摘要
 intcompareTo(T o) 
          比较此对象与指定对象的顺序。

代码实现如下：

    <1>.步骤：new TreeSet()集合会按元素的自然顺序排序，然后就是是自定义对象具有比较性

    <2>.特殊知识点：如果按照代码的上下顺序输出结果，可使compareTo方法返回值为1或者-1

/**
*需求：Tree集合对自定义对象的比较性实现方法1
*思路：1.比较性接口是Comparable
*	  2.compareTo方法返回正数则大，负数则小，0则是等于
*	  3.返回值为0视为两个对象相同，将不放进集合中
*/
import java.util.*;

class java
{
	public static void main(String[] args){
		TreeSet<Student> hs = new TreeSet<Student>();
		hs.add(new Student("伊利亚斯菲尔",14));
		hs.add(new Student("爱丽丝菲尔",15));
		hs.add(new Student("阿尔托利亚",16));
		hs.add(new Student("远坂凛",15));
		hs.add(new Student("间桐樱",15));

		for(Iterator<Student> it = hs.iterator();it.hasNext();){
			Student s = it.next();
			System.out.println(s.getName()+"\t永远的青春"+s.getAge());
		}
	}
}

class Student implements Comparable<Student>//该接口让学生具有比较性
{
	private String name;
	private int age;

	Student(String name,int age){
		this.name = name;
		this.age = age;
	}

	public String getName(){
		return name;
	}

	public int getAge(){
		return age;
	}

	public int compareTo(Student t){
		if((age - t.age)==0)
			//主要条件相同要排序次要条件
			return name.compareTo(t.name);//字符串自己的compareTo方法
		else
			return age - t.age;//可根据来改变排序次序，倒叙，正序
	}
}

（3）使其具有比较性的方法2：实现Comparator接口（元素具有的比较性不是被我们所要，让集合具备比较性）

   <1>.步骤：在集合初始化时，就有了比较方式。可以用new TreeSet(Conparator c)使比较性具有比较性，来实现元素的顺序

/**
*需求：Tree集合对自定义对象的比较性实现方法2
*思路：1.使集合具有比较性
*	  2.通过向TreeSet传入比较器来使其具有比较性
*/
import java.util.*;

class java
{
	public static void main(String[] args){
		//向TreeSet传入比较器使其具有比较性（这里使用的是匿名内部类）接口增加了扩展性
		TreeSet<Student> hs = new TreeSet<Student>(new Comparator<Student>(){
			
			public int compare(Student s1,Student s2){
				if((s1.getAge()-s2.getAge())==0)
					return s1.getName().compareTo(s2.getName());
				else
					return s1.getAge()-s2.getAge();
			}
		});
		hs.add(new Student("伊利亚斯菲尔",14));
		hs.add(new Student("爱丽丝菲尔",15));
		hs.add(new Student("阿尔托利亚",16));
		hs.add(new Student("远坂凛",15));
		hs.add(new Student("间桐樱",15));

		for(Iterator<Student> it = hs.iterator();it.hasNext();){
			Student s = it.next();
			System.out.println(s.getName()+"\t永远的青春"+s.getAge());
		}
	}
}

class Student
{
	private String name;
	private int age;

	Student(String name,int age){
		this.name = name;
		this.age = age;
	}

	public String getName(){
		return name;
	}

	public int getAge(){
		return age;
	}
}

二. Map集合

1.特点：该集合存储键值对，一对一对往进存，而且要保证键的唯一性

方法摘要
 Vput(K key, V value) 
          将指定的值与此映射中的指定键关联（可选操作）。(增加，当键重复时，会覆盖原先的值，并且此方法会返回被覆盖的值）
 voidputAll(Map<? extends K,? extends V> m) 
          从指定映射中将所有映射关系复制到此映射中（可选操作）。(增加）
 Vremove(Object key) 
          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。(删除）
 voidclear() 
          从此映射中移除所有映射关系（可选操作）。(删除）
 booleancontainsKey(Object key) 
          如果此映射包含指定键的映射关系，则返回 true。(判断）
 booleancontainsValue(Object value) 
          如果此映射将一个或多个键映射到指定值，则返回 true。(判断）
 booleanequals(Object o) 
          比较指定的对象与此映射是否相等。(判断）
 booleanisEmpty() 
          如果此映射未包含键-值映射关系，则返回 true。(判断）
 Vget(Object key) 
          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。(获取，能过传入null）
 intsize() 
          返回此映射中的键-值映射关系数。(获取）
 Collection<V>values() 
          返回此映射中包含的值的 Collection 视图。(获取）
 Set<K>keySet() 
          返回此映射中包含的键的 Set 视图。(重要）
 Set<Map.Entry<K,V>>entrySet() 
          返回此映射中包含的映射关系的 Set 视图。(重要）

Map.Entry<K,V>接口

1.把Map集合中的关系存入到Set集合中

方法摘要
 booleanequals(Object o) 
          比较指定对象与此项的相等性。
 KgetKey() 
          返回与此项对应的键。(取关系的键）
 VgetValue() 
          返回与此项对应的值。(取关系的值）
 inthashCode() 
          返回此映射项的哈希码值。
 VsetValue(V value) 
          用指定的值替换与此项对应的值（可选操作）。

1.HashMap

（1）特点：底层是哈希表数据结构，线程不同步

（2）集合中两种取出方法

class StudentOfMap {

	/**
	 *需求：每一个学生都有对应的归属地，学生Student，地址String，学生属性姓名，年龄，姓名年龄相同视为同一个学生，保证学生唯一性 
	 *思路：1.定义一个学生类，复写equals、hashCode、compareTo方法
	 *	   2.定义HashMap集合，键存储学生，值存储地址，以为健必须保证唯一性
	 * @param args
	 */
	public static void main(String[] args) {
		Map<Student,String> map = new HashMap<Student,String>();
		map.put(new Student("王逊",14), "昌平区");
		map.put(new Student("王逊",151), "昌平区");
		map.put(new Student("张欣",15), "朝阳区");
		map.put(new Student("张欣",15), "朝阳区");
		map.put(new Student("郑天成",167), "东城区");
		
		
		//keySet取出方式
		Set<Student> ss = map.keySet();
		for(Student s : ss){
			System.out.println(s+","+map.get(s));
		}
		System.out.println();
		//entrySet取出方式
		Set<Map.Entry<Student, String>> entry = map.entrySet();
		for(Map.Entry<Student, String> s : entry){
			System.out.println(s.getKey()+","+s.getValue());
		}
	}
}
//学生类
class Student implements Comparable<Student> {

	private String name;//姓名
	private int age;//年龄
	
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	
	//哈希code方法
	public int hashCode() {
		return this.name.hashCode()+age*23;
	}

	//equals方法
	public boolean equals(Object obj) {
		if(!(obj instanceof Student))
			throw new ClassCastException("传入类型错误");
		Student s = (Student)obj;
		return this.name.equals(s.getName()) && this.age == s.getAge();
	}
	
	//相比较的方法
	public int compareTo(Student o) {
		if(age == o.getAge())
			return this.name.compareTo(o.getName());
		else
			return age-o.getAge();
	}

	//字符串输出方法
	public String toString() {
		return name+"..."+age;
	}
	
}

（3）取出一个字符串中全部相同元素

public class Test2 {

	/**
	 * "avadsvasdgsagas"这个字符串以这个形式：打印
	 */
	public static void main(String[] args) {
		String str = "avadsvasdgsagas";
		Map<String,Integer> hm = new HashMap<String,Integer>();
		for(int x = 0;x<str.length();x++){
			String ch = str.charAt(x)+"";
			Integer value = hm.get(ch);//获取键对应的值
			if(value==null)//键不存在，存入
				hm.put(ch, 1);
			else//键存在，值自增
				hm.put(ch,++value);
		}
		
		Set<Map.Entry<String, Integer>> entry = hm.entrySet();//取出方法
		for(Map.Entry<String, Integer> e : entry){
			System.out.print(e.getKey()+"("+e.getValue()+")");//打印方法
		}
	}
}

2.TreeMap

（1）特点：底层是二叉树数据结构，线程不同步

3.Hashtable

（1）特点：底层是哈希表结构，不允许使用null键null值，线程同步

三. 集合工具包

1.Collections类

方法摘要
static
<T extends Comparable<? super T>> 
void
sort(List<T> list) 
          根据元素的自然顺序 对指定列表按升序进行排序。（方法上的泛型，指集合中元素必须实现Comparable接口）
static
<T> void
sort(List<T> list, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定列表进行排序。（自定义传入比较器）
static
<T> int
binarySearch(List<? extends Comparable<? super T>> list, T key) 
          使用二分搜索法搜索指定列表，以获得指定对象。（如果未查找到，返回的是 “-(插入点) - 1“）
static
<T> int
binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
          使用二分搜索法搜索指定列表，以获得指定对象。
static
<T> void
copy(List<? super T> dest, List<? extends T> src) 
          将所有元素从一个列表复制到另一个列表。
static
<T> void
fill(List<? super T> list, T obj) 
          使用指定元素替换指定列表中的所有元素。
static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一个值替换列表中出现的所有某一指定值。（替换集合中一个元素为指定元素）
static voidswap(List<?> list, int i, int j) 
          在指定列表的指定位置处交换元素。
static voidreverse(List<?> list) 
          反转指定列表中元素的顺序。
static
<T> Comparator<T>
reverseOrder() 
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。（反转）
static
<T> Comparator<T>
reverseOrder(Comparator<T> cmp) 
          返回一个比较器，它强行逆转指定比较器的顺序。（反转）
static voidshuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。
static voidshuffle(List<?> list, Random rnd) 
          使用指定的随机源对指定列表进行置换。
static
<T extends Object & Comparable<? super T>> 
T
max(Collection<? extends T> coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。
static
<T> T
max(Collection<? extends T> coll, Comparator<? super T> comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static
<T extends Object & Comparable<? super T>> 
T
min(Collection<? extends T> coll) 
          根据元素的自然顺序 返回给定 collection 的最小元素。
static
<T> T
min(Collection<? extends T> coll, Comparator<? super T> comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static
<T> List<T>
emptyList() 
          返回空的列表（不可变的）。
static
<K,V> Map<K,V>
emptyMap() 
          返回空的映射（不可变的）。
static
<T> Set<T>
emptySet() 
          返回空的 set（不可变的）。
static
<T> boolean
addAll(Collection<? super T> c, T... elements) 
          将所有指定元素添加到指定 collection 中。（方便的向集合中添加元素的方法）
static
<T> Collection<T>
synchronizedCollection(Collection<T> c)
          返回指定 collection 支持的同步（线程安全的）collection。
static
<T> List<T>
synchronizedList(List<T> list)
          返回指定列表支持的同步（线程安全的）列表。
static
<K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
          返回由指定映射支持的同步（线程安全的）映射。
static
<T>Set<T>
synchronizedSet(Set<T> s)
          返回指定 set 支持的同步（线程安全的）set。

2.Arrays类

注意：各种基本数据类型参数列表的重载未包括
方法摘要
static
<T> List<T>
asList(T... a)
          返回一个受指定数组支持的固定大小的列表。（把数组变成List集合）
static
<T> int
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
          使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static
<T> int
binarySearch(T[] a, T key,Comparator<? super T> c)
          使用二分搜索法来搜索指定数组，以获得指定对象。
static
<T> T[]
copyOf(T[] original, int newLength)
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static
<T> T[]
copyOfRange(T[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。（复制一个范围）
static
<T> T[]
copyOfRange(T[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。
static booleanequals(Object[] a,Object[] a2)
          如果两个指定的 Objects 数组彼此相等，则返回 true。（比较两个数组中的值是否相同）
static voidfill(Object[] a, int fromIndex, int toIndex,Object val)
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static voidfill(Object[] a,Object val)
          将指定的 Object 引用分配给指定 Object 数组的每个元素。
static voidsort(short[] a, int fromIndex, int toIndex)
          对指定 short 型数组的指定范围按数字升序进行排序。
static
<T> void
sort(T[] a,Comparator<? super T> c)
          根据指定比较器产生的顺序对指定对象数组进行排序。
static
<T> void
sort(T[] a, int fromIndex, int toIndex,Comparator<? super T> c)
          根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
static StringtoString(Object[] a)
          返回指定数组内容的字符串表示形式。
数组变为集合：
（1）可以用集合的中的方法和思想操作数组
（2）不能使用增加删除的方法操作该集合
（3）基本数据类型数组Arrays.asList(arr)方法不能识别，会自动识别为只有一个元素，该元素为一个数组。
桃华月禅
关注
专栏目录
Java入门第111课——集合addAll、containsAll的用法
Java学习博客
08-19 1373
测试Collection接口中addAll方法、containsAll方法的用法，详细要求如下：1）使用ArrayList构建集合c1，将字符串“java”、“cpp”、“php”、“c#”、“objective-c”放入集合c1中，并输出集合c1。2）使用HashSet构建集合c2，将集合c1中的元素添加到集合c2，并输出集合c2。3）使用ArrayList构建集合c3，将字符串“java”、“cpp”放入集合c3中，并判断集合c1中是否包含集合c3。
详解Java基础知识——JDBC
08-26
Java基础知识——JDBC Java DataBase Connectivity（JDBC）是一种用于执行SQL语句的Java API。JDBC提供了很多接口，然后不同数据库厂商去实现这个接口，以便降低操作数据的难度。 知识点一：JDBC的基本概念 *...
Set中的add和addAll方法
一片蓝蓝的云
07-27 2457
最近发现不太清楚Set中add和addAll方法的使用，于是经过学习发现： add方法是用来添加具体的类型，如果你设置了Set<String> set=new HashSet<>();那在add时，只可以添加String类型的参数。 addAll方法是用来添加集合的，如下： boolean addAll(Collection<? extends E> c); 不同点：添加参数的类型不同 总结：问题虽然小，但是每个一点一滴的积累来源于每次的疑问，只有这样
第八部分 集合 学习笔记
影扶疏
06-21 202
一、概述 1.集合有四种体系，Set、List、Queue、Map。 set无序不可重复 List有序可重复 Queue队列集合 Map映射关系 2.Java集合就像容器。将多个对象的引用扔进容器中。 3.为什么有集合类？为了保存数量不确定的数据，保存具有映射关系的数据（关联数组） 4.数组元素可以是基本类型值，也可以是对象的引用变量。 但是集合只能保存对象（对象的引用变量）。 5.集合主要两个接...
Java Set接口方法测试,HashSet,TreeSet方法测试（详）# descendingSet#headSet#subSet#tailSet
Fooler233的博客
08-19 677
1.Set接口是Collection接口的一个子接口，包含了collection接口的所有方法，并没有新增方法。2.存储在Set集合中的元素要求：a.不可重复，重复会报错。加入Set里面的元素必须定义equals()方法以确保对象的唯一性。set中插入数据时，先比较hashCode。如果hashCode相同才会比较equals，equals相同，则两个对象相同，新值会覆盖当前值。equals不同，可以插入。
Java——Java集合那些事
用代码征服天下
08-30 98
集合概述： 集合和数组都可以保存多个对象，但是数组的长度不可变，集合可以保存数量变化的数据。java中的集合类主要由两个接口派生出，Collection和Map Collection接口和Iterator接口： 概述：Collection接口是List，Set和Queue接口的父接口 Collection中的主要方法如下： Collection接口中方法 方法名称 方法概述 bo...
java的集合框架1
08-08
首先，我们关注Java集合框架的基础——Collection接口。Collection是所有集合类型的顶级接口，它定义了一组通用的操作方法，如add()、remove()和iterator()。Collection接口的主要特点是它存储一组不重复的元素，...
Java基础 学习笔记 Markdownr版
06-27
2. 集合：在13集合.md中，详细讲解了Java集合框架，包括ArrayList、LinkedList、HashSet、HashMap等基本集合类的使用，以及List、Set、Map接口的特性。此外，还可能涉及泛型的概念，泛型（14泛型.md）提高了代码的...
java基础学习——类型转换.doc
09-30
这在使用集合框架或其他需要对象而不是基础类型的地方非常有用。自动包装和解包在隐式转换中发生，无需显式调用构造函数或 `valueOf()` 方法。 理解这些类型转换规则对于编写健壮的 Java 代码至关重要，避免在处理...
Java并发编程之——Amino框架
08-10
Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨了Amino框架的设计理念、核心功能以及如何在实际项目中应用。 Amino框架可能提供了以下一些关键...
Set接口的使用
yuan_boss的博客
06-06 150
Set接口的使用 Set接口与Collection接口的使用差不多，都是有以下常用方法 add(),remove(),clear(),contains(),isEmpty(),itrator() 注意：因为Set集合是无下标，无序，不能重复的，所以遍历输出的结果可能与添加的顺序不同，添加重复元素会添加失败 代码实现 /** * 测试Set接口的使用 * 特点：无序，无下标，不能重复 */ public class Test { public static void main(String[]
Java类集
weixin_41706542的博客
09-06 150
数组有长度限制，有时候使用起来不方便 类集是一个动态的对象数组，不受对象数组长度的限制（同一类型且长度不固定）   类集常用接口： Collection接口：存放同一类型值的最大父类 int size(); boolean isEmpty(); boolean contains(Object o); Iterator&lt;E&gt; iterator(); Object[] t...
020 Java 集合
huayizhixing的专栏
12-01 407
1.集合Collection：是指可以存储一组数据的数据结构，集合是一个接口，其定义了丰富的方法。 1.1List和Set：在实际的开发中，要将使用对象存储于特定的数据结构，java提供的容器为：集合。集合是一个接口，定义了集合的相关操作方法，其有两个子接口。：List和Set 比较两个子接口需要看看集合中的元素需不需要重复。 当集合中的元素可以重复时，使用List            
java集合Collection
没有经过测试的代码都是耍流氓
08-20 667
/** 集合总结:  在集合中有两个接口是非常重要的，即Collection和Map;在这两个集合的基础上，又有一些完成特定功能 的其它子集合和实现类，下面就详细介绍一下其中非常重要的。  下面代码是在API1.6版本下完成的,以下学习中的方法介绍请参考API Collection  :java.util包中  |--Set   元素是无序的，所谓无序即不经其它处理，存入顺序和取出顺
黑马程序员__JAVA基础__集合(一)
有志者、事竟成、破釜沉舟
06-02 510
------------android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.概述     面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。     java语言的java.util包中提供了一些集合类，这些集合又被成为容器，提到容器不难会想象到数组，集合类与
set集合中的contains操作
奈若何
05-12 299
https://blog.csdn.net/wangjunchao111/article/details/50527004?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2aggregatepagefirst_rank_ecpm_v1~rank_v31_ecpm-13-50527004-null-null.pc_agg_new_rank&utm_term=Set+%E4%B8%AD%E7%9A%84contains%E6%
测试方法addAll、containsAll的用法
weixin_30508309的博客
06-01 261
import java.util.ArrayList;import java.util.Collection;import java.util.HashSet;import org.junit.Test;public class TestCollection { @Test public void testAddAllAndContainsAll(){ Collect...
Collection 中带有All结尾的常用方法：addAll（），removeAll（），containsAll（），retainAll（） 。
努力努力再努力
06-28 3929
Collection中带有All的方法：                                                        Collection list1 = new ArrayList（）；                                                        Collection list2 = new ArrayList（...
Set接口常用方法的简单应用
weixin_43787492的博客
08-10 1609
1、Set接口特点：不包含重复元素，无序且唯一。 2、常用方法如下： boolean add (E e ) 如果set中尚未包含指定元素，则添加指定元素。 void clear () 从此set中移除所有的元素。 boolean contains( Object o) 如果此 set包含指定元素 ，则返回true。 boolean remove( O...
Java集合框架：List接口与ArrayList详解
Java的集合框架是Java平台提供的一种强大的数据管理工具，它主要由一组操作对象的接口组成，这些接口包括Collection、List、Map等，分别对应不同类型的数据结构。在这个框架中，List接口是一个关键的部分，其中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值