1.集合的概念
-
集合:对象的容器,实现了对对象常用的操作,类似数组的功能
-
和数组的区别:数组长度固定,集合长度不固定;数组可以存储基本数据类型和引用类型,集合只能存储引用类型。
2.Collection接口
特点:代表一组任意类型的对象,无序,无下标,不能重复。
方法:
- add(Object o) 往集合中添加元素
- remove(Object o) 从集合中删除元素
- 遍历元素(增强for循环;还有就是迭代器Iterator 它里面有三种方法hasNext()是否有下一个元素,next()获取下一个元素,remove()删除元素)
- 判断(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接口与实现类
特点:有序,有下标,元素可以重复。
- void add(int index,Object o);//在index位置插入对象o(这是与Collection接口的区别,因为它没有下标)
- boolean addAll(int index,Collection c)//将一个集合中的元素添加到次集合中的index位置
- Object get(int index);//返回集合中指定位置的元素
- 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:
- 数组结构实现,查询快,增删慢
- JDK1.2版本,运行效率快,线程不安全
Vector:
- 数组结构实现,查询快,增删慢
- 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:
- 链表结构实现,增删快,查询慢
评:因为List继承于Collection,而ArrayList,linkedList,Vector或继承或实现了List这个类,所以Collection中有的方法,它们都有。然后把不同的着重记忆即可。比如Collection没有下标,而List有下标,所以它们遍历的时候方式也会有所增加(在Collection、List类的基础上)
ArrayList源码分析:
private static final int DEFAULT_CAPACITY = 10;默认容量 (注:如果没有向集合添加任何元素时,容量为0,如果添加一个元素之后,那么容量为10 ,其中扩容每次都是原来的1.5倍)
4.泛型和工具类
- Java泛型是JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递
- 常见的形式是泛型类、泛型接口、泛型方法(也就是再类、接口、方法中使用泛型)
- 好处:提高代码的重用性;防止转换类型异常,提高代码的安全性
泛型类的语法:
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:
- 基于排序顺序实现元素不重复
- 实现了SortedSet接口,对集合元素进行自动排序
- 元素对象的类型必须实现Compareble接口,指定排序规则
- 通过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接口的特点:
- 用于存储任意键值对(key-value)
- 键:无序,无下标,不允许重复(唯一)
- 值:无序,无下标,允许重复
方法:
- put();添加元素
- remove();删除元素
- keySet();获取键,是一个set集合,然后可以选择增强for来进行遍历
- 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个,那么就需要扩容)
总结:
- HashMap 刚创建时,table为null,为了节省空间,当添加第一个元素的时候,table的容量调整为16
- 当元素的个数大于阈值(16*0.75=12)时,会进行扩容,扩容后会变成为原来的2倍。目的是减少调整元素的个数。
- jdk1.8 当每个链表的长度大于8,并且数组元素的个数大于等于64时,会调整为红黑树,目的是提高执行效率
- jdk1.8 当链表的长度小于6时,会调整成链表
- jdk1.8以前,链表是头插入,jdk1.8以后,链表是尾插入
HashMap:
- JDK1.2版本,线程不安全,运行效率快;允许用null作为key或是value
HashTable:(基本不用)
- JDK1.0版本,线程安全,运行效率慢;不允许null作为key或是value
Properties:(继承了HashTble,与l流关系比较紧密)
- 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工具类
概念:集合工具类,定义了除了存取以外的集合的常用方法
方法:
- public static void reverse(List<?> list)//反转集合中元素的顺序
- public static void shuffle(List<?> list) //随机重置集合元素的顺序
- 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]