java基础 day14---集合框架

1.集合的概念

  1. 集合:对象的容器,实现了对对象常用的操作,类似数组的功能

  2. 和数组的区别:数组长度固定,集合长度不固定;数组可以存储基本数据类型和引用类型,集合只能存储引用类型。

2.Collection接口
特点:代表一组任意类型的对象,无序,无下标,不能重复。
方法:

  1. add(Object o) 往集合中添加元素
  2. remove(Object o) 从集合中删除元素
  3. 遍历元素(增强for循环;还有就是迭代器Iterator 它里面有三种方法hasNext()是否有下一个元素,next()获取下一个元素,remove()删除元素)
  4. 判断(contains()判断是否包含某元素,isEmpty()集合是否为空)

这里添加的是字符串:

//创建集合的对象(虽然Collection是接口,但是可以ArrayList或者HashSet)
		Collection collection =new ArrayList();
		
		//1.添加元素add()
		collection.add("香蕉");
		collection.add("苹果");
		collection.add("梨");
		System.out.println(collection.size());//3
		System.out.println(collection.toString());//[香蕉, 苹果, 梨]
		
		//2.删除元素
		collection.remove("香蕉");
		System.out.println(collection);//[苹果, 梨]
//		 //清空元素
//		collection.clear();
//		System.out.println(collection.size());//0
//		System.out.println(collection);//[]
//		
		//3.遍历元素
		//3.1使用增强for
		System.out.println("============3.1使用增强for==============");
		for(Object o:collection) {
			System.out.println(o);
		}
		
		//3.2使用迭代器(专门用来遍历集合的方式)
		//hasNext()有没有下一个元素  next()获取下一个元素  remove()删除当前元素
		System.out.println("============3.2使用迭代器(专门用来遍历集合的方式)==============");
		Iterator iterator=collection.iterator();
		while(iterator.hasNext()) {
			Object o=iterator.next();
			System.out.println(o);
//			collection.remove(o);
			iterator.remove();
		}
		System.out.println(collection.size());//0
		
		//4.判断元素是否存在
		boolean b=collection.contains("西瓜");
		System.out.println(b);//false
		
		//5.判断集合是否为空
		boolean b1=collection.isEmpty();
		System.out.println(b1);//true
		

这里添加的是学生对象:

//创建Collection对象
		Collection collection=new ArrayList();
		
		//创建学生对象
		Student s1=new Student("张丹",20);
		Student s2=new Student("王元",21);
		Student s3=new Student("李梅",20);
		
		//1.添加元素
		collection.add(s1);
		collection.add(s2);
		collection.add(s3);
		System.out.println(collection.size());//3
		
		//2.删除元素
		collection.remove(s1);
		System.out.println(collection.size());//2
		
		//3.遍历元素
		//3.1增强for
		for(Object o:collection) {
//			Student s=(Student)o;
			System.out.println(o);//Student [name=王元, age=21]   Student [name=李梅, age=20]
		}
		//3.2迭代器遍历
		Iterator iterator = collection.iterator();
		while(iterator.hasNext()) {
			Object next = iterator.next();
			System.out.println(next);
		}
		
		//4.判断 
		//4.1判断是否包含李梅
		boolean b = collection.contains(s3);
		System.out.println(b);//true
		//4.2判断是否为空
		boolean b1 = collection.isEmpty();
		System.out.println(b1);//false

3.List接口与实现类
特点:有序,有下标,元素可以重复。

  1. void add(int index,Object o);//在index位置插入对象o(这是与Collection接口的区别,因为它没有下标)
  2. boolean addAll(int index,Collection c)//将一个集合中的元素添加到次集合中的index位置
  3. Object get(int index);//返回集合中指定位置的元素
  4. List subList(int fromIndex,int toIndex);//返回从fromIndex和toIndex之间的集合元素
//创建List对象
		List list=new ArrayList();
		
		//1.添加元素add(),add(int index)
		list.add("苹果手机");
		list.add("小米手机");
		list.add(0,"华为手机");
		System.out.println(list.size());//3
		System.out.println(list);//[华为手机, 苹果手机, 小米手机]
		
		//2.删除元素 remove(object o)  remove(int index)
//		list.remove("小米手机");
		list.remove(0);
		System.out.println(list.size());//2
		System.out.println(list);//[苹果手机, 小米手机]
		
		//3.遍历(有四种方式)
		//3.1 for循环(因为有下标)
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));//苹果手机  小米手机
		}
		
		//3.2增强for循环
		for(Object s:list) {
			System.out.println(s);苹果手机  小米手机
		}
		
		//3.3使用迭代器
		Iterator iterator = list.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());//苹果手机  小米手机
		}
		
		//3.4使用ListIterator,可以向前或向后遍历
		ListIterator listIterator = list.listIterator();
		while(listIterator.hasNext()) {
			System.out.println(listIterator.next());//苹果手机  小米手机
		}
		
		//从后往前,是在从前往后的基础上(因为从前往后,指针移到了最后)
		while(listIterator.hasPrevious()) {
			System.out.println(listIterator.previousIndex()+":"+listIterator.previous());//1:小米手机  0:苹果手机
			
		}
		
		//4.判断
		System.out.println(list.contains("三星"));//false
		System.out.println(list.contains("苹果手机"));//true
		System.out.println(list.isEmpty());//false
		
		//5.获取位置
		System.out.println(list.indexOf("三星"));//-1  代表找不到
		System.out.println(list.indexOf("苹果手机"));//0
		
		list.add("三星手机");
		list.add("vivo手机");
		list.add("oppo手机");
		list.add("红米手机");
		System.out.println(list.toString());//[苹果手机, 小米手机, 三星手机, vivo手机, oppo手机, 红米手机]
		
		//6.subList()返回子集合
		List sublist=list.subList(2, 5);//第一个参数包括,后一个参数不包括
		System.out.println(sublist);//[三星手机, vivo手机, oppo手机] 
	

注意:集合中不能添加基本数据类型,所以你添加的时候很多都是自动转换成包装类类型。但是当你删除某个元素的时候要注意这个问题。

ArrayList:

  1. 数组结构实现,查询快,增删慢
  2. JDK1.2版本,运行效率快,线程不安全

Vector:

  1. 数组结构实现,查询快,增删慢
  2. JDK1.0版本,运行效率慢,线程安全

没有太大区别,主要就是遍历方法多了一个枚举器。当然还有一些新增的其他方法,用到再看即可。

//创建Vector集合
		Vector vector=new Vector();
		
		//1.添加元素
		vector.add("草莓");
		vector.add("芒果");
		vector.add("西瓜");
		
		System.out.println(vector.size());
		
		//2.遍历
		//2.1 增强for
		for(Object o:vector) {
			System.out.println(o);
		}
		
		//2.1-1for循环
		for(int i=0;i<vector.size();i++) {
			System.out.println(vector.get(i));
		}
		
		//2.2迭代器
		Iterator it = vector.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("----------------------");
		//2.3列表迭代器
		
		ListIterator lit = vector.listIterator();
		
		while(lit.hasNext()) {
			System.out.println(lit.next());
		}
		
		while(lit.hasPrevious()) {
			System.out.println(lit.previous());
		}
		
		//2.4枚举器
		Enumeration elements = vector.elements();
		while(elements.hasMoreElements()) {
			System.out.println(elements.nextElement());
		}
		
		
		//3.删除remove()
		//4.判断contains()
		//5.判断是否为空  isEmpty()

LinkedList:

  1. 链表结构实现,增删快,查询慢

评:因为List继承于Collection,而ArrayList,linkedList,Vector或继承或实现了List这个类,所以Collection中有的方法,它们都有。然后把不同的着重记忆即可。比如Collection没有下标,而List有下标,所以它们遍历的时候方式也会有所增加(在Collection、List类的基础上)

ArrayList源码分析:
private static final int DEFAULT_CAPACITY = 10;默认容量 (注:如果没有向集合添加任何元素时,容量为0,如果添加一个元素之后,那么容量为10 ,其中扩容每次都是原来的1.5倍)


4.泛型和工具类

  1. Java泛型是JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递
  2. 常见的形式是泛型类、泛型接口、泛型方法(也就是再类、接口、方法中使用泛型)
  3. 好处:提高代码的重用性;防止转换类型异常,提高代码的安全性

泛型类的语法:

public class MyGeneric <T> {

泛型接口的语法:

public <T>void show() {

MyMethod类:

public <T>void show(T t) {
		System.out.println(t);
	}

测试类:

	MyMethod method=new MyMethod();
		method.show("加油!");//自动是String
		method.show(20);//Integer
		method.show(3.14);//Double
		
		/**
		 * 相当于重载了。。。。
		 */

泛型集合:主要起到了一个约束作用。
比如:ArrayList arrayList=new ArrayList();
这样arrayList对象在使用add()方法的时候,就会只能添加Student类型的,遍历的时候也不需要强制类型转换,把Object转换成其类型了。。。
5.Set接口与实现类
特点:无序,无下标,元素不可以重复。
方法:全部继承于Collection的方法,并没有定义新的方法

//创建集合
		Set <String> set=new HashSet<String>();
		
		//1.添加数据
		set.add("小米");
		set.add("华为");
		set.add("三星");
		set.add("苹果");
		set.add("苹果");//重复的不添加
		System.out.println(set.size());//4   
		System.out.println(set);//[苹果, 华为, 小米, 三星]   打印的与添加的顺序不一致
		
		//2.删除数据
		set.remove("小米");
		System.out.println(set.toString());//[苹果, 华为, 三星]
		
		//3.遍历(2种方式)
		//3.1增强for
		for(String s:set) {
			System.out.println(s);
		}
		
		//3.2迭代器
		Iterator<String> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//4.判断
		boolean b=set.contains("华为");
		boolean b1=set.isEmpty();
		System.out.println(b);//true
		System.out.println(b1);//false

评:与Collection中基本一致。。。。

Set实现类:
HashSet:
存储结构:哈希表(数组+链表+红黑树)

//新建一个集合
		HashSet<String> hashSet=new HashSet<String>();
		
		//1.添加元素
		hashSet.add("刘德华");
		hashSet.add("周润发");
		hashSet.add("周星驰");
		hashSet.add("刘德华");
		System.out.println(hashSet.size());//3
		System.out.println(hashSet.toString());//[周星驰, 周润发, 刘德华]   无序的,并且不允许重复
		
		//2.删除元素
		hashSet.remove("刘德华");
		System.out.println(hashSet.size());//2
		System.out.println(hashSet);//[周星驰, 周润发]
		
		//3.遍历
		//3.1增强for
		for(String s:hashSet) {
			System.out.println(s);
		}
		
		//3.2迭代器
		Iterator<String> it = hashSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//4.判断
		boolean  b=hashSet.contains("郭富城");
		System.out.println(b);//false
		System.out.println(hashSet.isEmpty());//false
	}

存储过程:
(1)根据hashcode计算保存的位置,如果位置为空,则直接保存;如果不为空,则执行第二步
(2)再执行equals()方法,如果equals()方法为true,则认为重复,否则,形成链表。
重写equals方法,比较内容,而不是比较对象;以及重写hasCode方法:

	@Override
		public boolean equals(Object obj) {
			if(this==obj) {
				return true;
			}
			if(obj==null) {
				return false;
			}
			if(obj instanceof Person) {
				Person obj1=(Person)obj;
				if(this.name==obj1.getName()&&this.age==obj1.getAge()) {
					return true;
				}
			}
			return false;
		}
	
	@Override
	public int hashCode() {
		int n1=this.name.hashCode();
		int n2=this.age;
		return n1+n2;
	}

注:重写equals和hasCode方法,也可以 右键->Source->Generate hasCode() and equals()

	HashSet <Person> hashSet=new HashSet<Person>();
		
		//1.添加元素
		Person p1=new Person("杨幂",32);
		Person p2=new Person("赵丽颖",30);
		Person p3=new Person("刘诗诗",31);
		Person p4=new Person("唐嫣",32);
		hashSet.add(p1);
		hashSet.add(p2);
		hashSet.add(p3);
		hashSet.add(p4);
		hashSet.add(new Person("唐嫣",32));//需要重写equals()方法和hasCode()方法,否则就会添加上
		hashSet.add(p1);//重复,不添加
		System.out.println(hashSet.size());//4
		System.out.println(hashSet.toString());//[Person [name=赵丽颖, age=30], Person [name=刘诗诗, age=31], Person [name=杨幂, age=32], Person [name=唐嫣, age=32]]
	
		//2.删除操作
		hashSet.remove(p4);
		System.out.println(hashSet.size());//3
		
		hashSet.remove(new Person("赵丽颖",30));
		System.out.println(hashSet.size());//2(但是如果你没有重写equals和hashCode,那么也是删不掉的)
		
		//3.遍历
		//3.1增强for
		//3.2迭代器
		
		//4.判断

Set实现类:
TreeSet:

  1. 基于排序顺序实现元素不重复
  2. 实现了SortedSet接口,对集合元素进行自动排序
  3. 元素对象的类型必须实现Compareble接口,指定排序规则
  4. 通过CompareTo方法来确定是否为重复元素

存储结构:
红黑树(左节点<根节点<右节点)

1、存储的简单的String类型:

//创建集合
		TreeSet<String> treeSet=new TreeSet<String>();
		
		//1.添加元素
		treeSet.add("xyz");
		treeSet.add("hello");
		treeSet.add("abc");
		treeSet.add("xyz");//并没有添加进来
		System.out.println(treeSet.size());//3
		System.out.println(treeSet.toString());//[abc, hello, xyz]
		
		//2.删除元素
		treeSet.remove("xyz");
		System.out.println(treeSet);//[abc, hello]
		
		//3.遍历
		//3.1遍历增强for
		for(String s:treeSet) {
			System.out.println(s);
		}
		
		//3.2迭代器遍历
		Iterator<String> it = treeSet.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//4.判断
		System.out.println(treeSet.contains("abc"));//true
		System.out.println(treeSet.isEmpty());//false

2、存储引用类型:
使用TreeSet集合来保存数据,并指定排序规则

  • 存储结构:红黑树
  • 要求必须实现Comparable接口,compareTo();//如果返回值为0,则重复不添加
public class Person implements Comparable<Person>{
@Override
	public int compareTo(Person o) {
		//先比较名字在比较年龄(当然这个规则在于你自己)
		int n1=this.name.compareTo(o.getName());//如果为0,说明姓名相同,具体见源码
		int n2=this.age-o.getAge();
		return n1==0?n2:n1;
	}
//创建集合
		TreeSet<Person> treeSet=new TreeSet<Person>();
		
		//1.添加元素
				Person p1=new Person("杨幂",32);
				Person p2=new Person("赵丽颖",30);
				Person p3=new Person("刘诗诗",31);
				Person p4=new Person("唐嫣",32);
				treeSet.add(p1);
				treeSet.add(p2);
				treeSet.add(p3);
				treeSet.add(p4);
				treeSet.add(p4);//重复,不添加
				System.out.println(treeSet.size());//4
				System.out.println(treeSet.toString());//[Person [name=刘诗诗, age=31], Person [name=唐嫣, age=32], Person [name=杨幂, age=32], Person [name=赵丽颖, age=30]]
				

也可以用下面这种方式

package com.hp.set;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 	使用treeSet集合实现字符串按照长度进行排序
 * @author au
 *
 */
public class Demo6 {
	
	public static void main(String[] args) {
		//创建TreeSet集合,并指定规则
		TreeSet <String> treeSet=new TreeSet<String>(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				int n1=o1.length()-o2.length();
				int n2=o1.compareTo(o2);
				
				return n1==0?n2:n1;
			}
		});
		
		//字符串
		String s1="helloworld";
		String s2="zhang";
		String s3="lisi";
		String s4="wangwu";
		String s5="beijing";
		String s6="xian";
		String s7="nanjing";
		
		treeSet.add(s1);
		treeSet.add(s2);
		treeSet.add(s3);
		treeSet.add(s4);
		treeSet.add(s5);
		treeSet.add(s6);
		treeSet.add(s7);
		
		System.out.println(treeSet.size());
		System.out.println(treeSet.toString());//[lisi, xian, zhang, wangwu, beijing, nanjing, helloworld]
		
	}
	
	

}

6.Map接口与实现类
Map接口的特点:

  1. 用于存储任意键值对(key-value)
  2. 键:无序,无下标,不允许重复(唯一)
  3. 值:无序,无下标,允许重复

方法:

  1. put();添加元素
  2. remove();删除元素
  3. keySet();获取键,是一个set集合,然后可以选择增强for来进行遍历
  4. entrySet()获取键值对,也是一个set集合,然后选择增强for进行遍历
	//创建Map集合
		Map<String,String> map=new HashMap<>();
		
		//1.添加元素put()
		map.put("cn", "中国");
		map.put("uk", "英国");
		map.put("us", "美国");
		map.put("cn", "zhongguo");
		System.out.println(map.size());//3
		System.out.println(map.toString());//{uk=英国, cn=zhongguo, us=美国}  (注:覆盖了前一个键为cn的)
		
		//2.删除元素
		map.remove("us");
		System.out.println(map.size());//2
		System.out.println(map);//{uk=英国, cn=zhongguo}
		
		//3.遍历
		//3.1遍历keySet()
		Set<String> keySet = map.keySet();//得到的是set,所以就可以用前边学习的set的遍历方法
		for(String key:keySet) {
			System.out.println(key+": "+map.get(key));//uk: 英国    cn: zhongguo
		}
		
		
		//3.2使用entrySet()遍历
		Set<Entry<String, String>> entrySet = map.entrySet();
		for(Entry<String, String> s:entrySet) {
//			System.out.println(s);//uk=英国    cn=zhongguo
			
			//或者使用下述代码
			System.out.println(s.getKey()+": "+s.getValue());//uk: 英国     cn: zhongguo
		}
		/**
		 * entrySet的效率高于keySet
		 * keySet得到的是键
		 * entrySet得到的是键值对
		 */
		
		//4.判断
		System.out.println(map.containsKey("cn"));//true
		System.out.println(map.containsValue("泰国"));//false

HashMap:
特点:默认容量为16,默认加载因子为0.75(比如当容量为100的,如果超过75的话,就会进行扩容)

//创建一个集合
		HashMap<Student, String> hashMap = new HashMap<Student, String>();
		
		//1.添加元素
		Student s1=new Student("小明","10001");
		Student s2=new Student("小红","10002");
		Student s3=new Student("小青","10003");
		hashMap.put(s1, "北京");
		hashMap.put(s2, "上海");
		hashMap.put(s3, "广州");
		hashMap.put(new Student("小青","10003"), "广州"); //和hashSet差不多,所以都需要重写hashCode和equals方法
		System.out.println(hashMap.size());//3
		System.out.println(hashMap.toString());//{Student [stuNo=小青, name=10003]=广州, Student [stuNo=小明, name=10001]=北京, Student [stuNo=小红, name=10002]=上海}
		
		//2.删除元素
		hashMap.remove(s1);
		System.out.println(hashMap.size());//2
		System.out.println(hashMap.toString());//{Student [stuNo=小青, name=10003]=广州, Student [stuNo=小红, name=10002]=上海}
	
		//3遍历
		//3.1使用KeySet()方法进行遍历
		Set<Student> keySet = hashMap.keySet();
		for(Student key:keySet) {
			System.out.println(key+" :"+hashMap.get(key));
		}
		
		//3.2使用entrySet()方法进行遍历
		Set<Entry<Student,String>> entrySet=hashMap.entrySet();
		for(Entry<Student,String> s:entrySet) {
			System.out.println(s.getKey()+" :"+s.getValue());
		}
		
		//4.判断
		System.out.println(hashMap.containsKey(s1));//false
		System.out.println(hashMap.containsValue("北京"));//false
		System.out.println(keySet.contains(s1));//false

HashMap源码分析:

/**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//默认容量为16
/**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //最大容量为2^30
/**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //默认加载因子为0.75(注:当容量为100时,如果元素个数超过75个,那么就需要扩容)

总结:

  1. HashMap 刚创建时,table为null,为了节省空间,当添加第一个元素的时候,table的容量调整为16
  2. 当元素的个数大于阈值(16*0.75=12)时,会进行扩容,扩容后会变成为原来的2倍。目的是减少调整元素的个数。
  3. jdk1.8 当每个链表的长度大于8,并且数组元素的个数大于等于64时,会调整为红黑树,目的是提高执行效率
  4. jdk1.8 当链表的长度小于6时,会调整成链表
  5. jdk1.8以前,链表是头插入,jdk1.8以后,链表是尾插入

HashMap:

  1. JDK1.2版本,线程不安全,运行效率快;允许用null作为key或是value

HashTable:(基本不用)

  1. JDK1.0版本,线程安全,运行效率慢;不允许null作为key或是value

Properties:(继承了HashTble,与l流关系比较紧密)

  1. HashTable的子类,要求key或value都是String。通常用于配置的读取

TreeMap:实现了SortedMap接口(Map的子接口),可以对key进行自动排序

//新建一个集合
		TreeMap <Student,String> treeMap=new TreeMap<Student, String>();
		
		//1.添加元素
		Student s1=new Student("小明","10001");
		Student s2=new Student("小红","10002");
		Student s3=new Student("小青","10003");
		treeMap.put(s1, "北京");
		treeMap.put(s2, "杭州");
		treeMap.put(s3, "青岛");
		System.out.println(treeMap.size());
		System.out.println(treeMap.toString());

这时候会出现一个问题: com.hp.xxx.Student cannot be cast to java.lang.Comparable
解决方案:

public class Student implements Comparable<Student>{

并重写CompareTo()方法

@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
		int n1=this.name.hashCode()-o.getName().hashCode();
		int n2=this.stuNo.hashCode()-o.getStuNo().hashCode();
		return n1==0?n2:n1;
	}

此时就可以正常执行了。。。

//新建一个集合(如果你不想在Student类中实现Comparable,也可以在新建集合的构造器中创建一个Comparator,具体可见treeSet里的代码)
		TreeMap <Student,String> treeMap=new TreeMap<Student, String>();
		
		//1.添加元素
		Student s1=new Student("小明","10001");
		Student s2=new Student("小红","10002");
		Student s3=new Student("小青","10003");
		treeMap.put(s1, "北京");
		treeMap.put(s2, "杭州");
		treeMap.put(s3, "青岛");
		System.out.println(treeMap.size());//3
		System.out.println(treeMap.toString());//{Student [stuNo=小明, name=10001]=北京, Student [stuNo=小红, name=10002]=杭州, Student [stuNo=小青, name=10003]=青岛}
		
		
		//2.删除元素
		treeMap.remove(new Student("小青","10003"),"青岛");
		System.out.println(treeMap);
		
		//3遍历
		//3.1KeySet遍历
		Set<Student> students=treeMap.keySet();
		for(Student s:students) {
			System.out.println(s+" "+treeMap.get(s));
		}
		
		//3.2EntrySet遍历
		Set<Entry<Student, String>> entrySet = treeMap.entrySet();
		for(Entry<Student, String> e:entrySet) {
			System.out.println(e.getKey()+" "+e.getValue());
		}
		

7.Collections工具类
概念:集合工具类,定义了除了存取以外的集合的常用方法
方法:

  1. public static void reverse(List<?> list)//反转集合中元素的顺序
  2. public static void shuffle(List<?> list) //随机重置集合元素的顺序
  3. public static void sort(List list)//升序排序(元素类型必须实现Comparable接口)
//copy赋值
		List <String> destList=new ArrayList<String>();
		Collections.copy(destList, list);
		System.out.println(destList);
		//出现了Source does not fit in dest,这是因为destList必须和list必须容量相同

//解决方案是
for(int j=0;j<list.size();j++) {
			destList.add(list.get(j));
		}
//然后再赋值
List <String> list=new ArrayList<String>();
		list.add("hello");
		list.add("my");
		list.add("favorite");
		list.add("actor");
		System.out.println(list.size());
		System.out.println(list);//[hello, my, favorite, actor]
		System.out.println("---------反转顺序reverse--------------");
		//reverse反转
		Collections.reverse(list);
		System.out.println(list);//[actor, favorite, my, hello]
		
		//binarySearch(二分查找)
		int binarySearch = Collections.binarySearch(list, "my");
		System.out.println(binarySearch);//2(注:但是hello为什么不是3而是-3呢?个人觉得可能就是在二分查找之前,list并没有排序)
		
		//copy赋值
		List <String> destList=new ArrayList<String>();
		for(int j=0;j<list.size();j++) {
			destList.add(list.get(j));
		}
		Collections.copy(destList, list);
		System.out.println(destList);//[actor, favorite, my, hello]
		
		//排序 sort
		Collections.sort(list);
		System.out.println(list);//[actor, favorite, hello, my]
		
		//shuffle 打乱	(每次运行都不一样)
		Collections.shuffle(list);
		System.out.println(list);
		
		//list转换成数组(转换的目的主要就是可以使用数组的方法了)
		System.out.println("--------------list转换为数组-----------");
		String [] str=list.toArray(new String[10]);//这里长度给多少都行,因为如果它的长度小于list的长度,会自动转成list的长度
//		for(String s:str) {
//			System.out.println(s);
//		}
		System.out.println(Arrays.toString(str));//[hello, favorite, actor, my, null, null, null, null, null, null]
		
		
		//数组转换成集合list
		System.out.println("---------------数组转换成集合list-------------------");
		
//		//动态初始化
//		String [] names=new String[5];
//		names[0]="张三";
//		names[1]="李四";
//		names[2]="王五";
//		names[3]="赵六";
//		names[4]="于七";
//		System.out.println(names.length);//5
		
//		//静态初始化
//		String []names=new String[] {"张三","李四","王五","赵六","于七"};
//		System.out.println(names.length);//5
		
		//最简便的数组初始化
		String[]names= {"张三","李四","王五","赵六","于七"};
		System.out.println(names.length);//5
		
		//把数组转换成一个集合,这个集合是受限的集合,不可以添加或删除
		List<String> asList = Arrays.asList(names);
		
		System.out.println(asList);//[张三, 李四, 王五, 赵六, 于七]
		
		//把基本数据类型数组转换成集合时,需要修改为包装类
//		int [] nums= {100,128,189,203,29};
//		List<int[]> list2 = Arrays.asList(nums);
		Integer [] nums= {100,128,189,203,29};
		List <Integer> list2=Arrays.asList(nums);
		System.out.println(list2);//[100, 128, 189, 203, 29]
		
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值