java中集合框架学习笔记

集合

数组定义的时候就指定了类型

1、add的方法的参数类型 是object，以便于接受任意类型对象2、集合中存储的都是对象的引用（地址）

import java.util.*;
class CollectionDemo
{
    public static void main(String[] args)
    {
        ArrayList al = new Arraylist();
        al.add("java1111")
    }
}

迭代器

把取出的方式定义在集合的内部
这样取出方式就可以直接访问集合内容的元素
name取出方式就定义成了内部类

而容器的数据结构不同，所以去取出的细节不一样，但是都有共性的内容，判断和取出，name可以将写共性的抽取

这些内部类都符合一个规则，改规则是Iterator，如何获取集合的取出对象?通过一个对外提供的方法iterator（）

collection

list:元素可以重复，因为该集合体系有索引

子类对象

        ArrayList：底层的数据结构使用的是数组结构 特点：查询速度很快，但是增删稍慢（线程不同步）（默认长度为10，长度超过的时候new数组，50%延长，然后把之前的元素copy过去）
        LinkedList：底层使用的是链表数据结构 特点：查询慢，增删快
        Vector：底层是数组数据结构（线程同步，被ArrayList替代了）（默认长度为10，100
        %延长，浪费空间）（支持枚举）

set：元素是无序的，元素不可以重复

list：

特有方法：凡是可以操作角标的都是体系特有的方法

增
add(index,element)
删
remove（index）
改
set(index,element)
查
get(index)
sublist(from,to)
listiterator()

list集合特有的迭代器，listiterator是iterator的子接口
因为在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生concurrentmodificationexception异常

所以在迭代时，只能应迭代器的方法操作元素，可是iterator的方法是有限的，只能对元素进行判断，取出，删除的操作
如果想要娶她的操作如添加，修改等，接需要使用其子接口，listiterator

该接口只能通过list集合的listiterator方法获取

LinkedList

特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取但不删除，如没有元素会出现exception

removeFirst();
removeLast();
获取元素，并删除，如集合中没有元素，会出现nosuchexception

在jdk1.6中，出现了替代方法
offerFirst()/last

peakFirst()/last
获取元素，但不删除元素，如果集合中没有元素，获返回null

pollFirst()/last
获取元素，但是元素被删除，如果集合中没有元素，会返回null

使用LinkedList模拟一个堆栈或者队列数据结构

堆栈：先进后出
队列：先进先出，First in first out FIFO

ArrayList练习（增删值依赖equals）

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public boolean equals(Object obj)//重写父类中的equals方法
	{

		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		//System.out.println(this.name+"....."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	/**/
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class ArrayListTest
{
    pblic static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList a1 = new ArrayList();
        a1.add(new Person("lisi111",20));
        a1.add(new Person("lisi222",90));
    }
    Iterator it = a1.iterator;
    while(it.hasNext())
    {
        Person p = (Person)it.next();//必须向下转型，因为之前元素传给add的时候进行了向上转型
        sop(p.getName());
    }
}

去除重复元素
List集合判断元素是否相同，依据的是元素的equals方法
contains和remove依赖的都是equals

对象不同的时候需要改写equals的方法，方法在对象中（因为对象继承了object）

list选用

如果元素很多，涉及频繁的增删操作，选用LinkedList
涉及增删和查询，可用arraylist（频繁的增删并不常见，而且在数据不会太长的情况下允许使用arraylist）

set元素是无序（存入和取出的顺序不一定一直）元素不可以重复

set集合的功能和collection一致

常见的子类

    HashSet：底层的数据结构是哈希表
        HashSet如何是如何保证元素唯一性的呢？
        是通过元素的两个方法，hasCode和equals来完成（线程非同步）
        如果元素的HashCode值相同，才会判断equals是否为true
        如果元素的HashCode值不同，不会调用equals 
        
        注意：对于判断元素是否存在，以及删除等操作，以来的方法是元素的hashcode和equals方法
        
    TreeSet：可以对Set集合中的元素进行排序
        底层数据结构是二叉树
        保证唯一性的依据：
        compareTo方法return 0；
        
        排序的第一种方式
        1、让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然排序，或者叫做默认顺序
        2、当元素自身不具备比较性时或者具备的比较性不是所需要的
        这时就需要让集合自身具备比较性
        在集合一初始化时就有了比较方式

HashSet

往HashSet集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素

HashCode判断和删除的依据

TreeSet存储自定义对象

注意：排序时，当主要条件相同时，一定要判断一下次要条件(复写compareTo方法，继承Comparable)

需求：往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序

class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();
        
        ts.add(new Student("lisi01",20));
        ts.add(new Student("lisi02",21));
    }
}
class Student implements Comparable
{
    private Sting name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象")
        Student s = (Student)obj;
        
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

当元素自身不具备比较性，或者具备的比较性不是所需要的

这时需要让容器自身具备比较性
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
当两种排序都存在时，以比较器为主
实现一个Comparator接口，覆盖compare方法

import java.util.*;


class Student implements Comparable//默认的比较方法，实现了Comparable接口，重写compareTo方法
{
	private String name;
	private int age;

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

	public int compareTo(Object obj)
	{

		//return 0;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生");
		Student s = (Student)obj;

		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
		/**/
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetDemo2 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi02",21));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi007",29));
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

class MyCompare implements Comparator//实现了了Comparator接口，重写了compare方法
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;
		}
		return num;
	}
}

泛型：jdk1.5版本以后出现的特性，用于解决安全问题，是一个安全机制

好处
1、将运行时期出现问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全

2、避免了强制转换的麻烦

class GenericDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> a1 = new ArrayList<String>();//初始化时定义了数组存储的类型
        
        a1.add("abc01");
        a1.add("dwd12");
    }
    Iterator<String> it = a1.iterator();//迭代时定义数组的存储类型
    while(it.hasNext())
    {
        String s = it.next();
        System.out.println("dwdw");
             
    }
}

泛型使用

格式：通过<>定义要操作的引用类型
什么时候使用？
通常在集合框架下很常见，只要见到< >就要使用泛型

其实<>就是用来接收类型的

当使用集合时，将集合中要存储的数据类型作为参数查传递到<>中即可

注意：arraylist中复写equals方法不能使用泛型（因为object类中没有泛型）

import java.util.*;
class GenericDemo2 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());//泛型的使用

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");


		Iterator<String> it = ts.iterator();

		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s);
		}
	}
}


class LenComparator implements Comparator<String>//泛型记得写上类型
{
	public int compare(String o1,String o2)//类型与申明的时候相同
	{
		int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
 
		if(num==0)
			return o2.compareTo(o1);
		return num;
	}
}

泛型类

什么时候定义泛型类
当类中要操作的引用数据类型不确定的时候
早期定义Object来完成扩展
现在定义泛型类来扩展

class Utils<QQ>//定义一个类型的参数
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}
class GenericDemo3
{
    public static void mian(String[] args)
    {
        Utils<Worker> u = new Utils<Worker>();//将类型参数传入，生成
        
        u.setObject(new Worker());
        Worker w = u.getObject();
    }
}

泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

为了让不同的方法可以操作不同的类型，而且类型还不确定
那么就可以将泛型定义在方法上

静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上

class Demo
{
    public <T> void show(T t)//泛型定义在方法上，注意在修饰符后面加上泛型的修饰(返回值前面)
    {
        System.out.println(t);
    }
    public <Q> void println(Q q)
    {
        System.out.println(q);
    }
    public static <w> void method(W w)
    {
        System.out.println(w);
    }
}
class GenericDemo4
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        d.show("haha");
        d.show(new Interger(4));
        d.println("heihei");
        
        Demo.method("啊哈哈哈哈");
        
    }
}

泛型接口

interface Inter<T>
{
    void show(T t);
}
/*在定义实现的时候已经确定传入的类型
class InterImpl implements Inter<String>//定义了泛型的类型
{
    public void show(String t)
    {
        System.out.println(t);
    }
}
class GenericDemo
{
    public static void main(String[] args)
    {
        InterImpl i = new InterImpl();
        i.show("hahaha");
    }
}
*/
class InterImpl<T> implements Inter<T>//在实现的时候不明确参数的类型
{
   public void show(T t);
   {
       System.out.println(t);
   }
    public static void main(String[] args)
    {
        InterImpl<Interger> i = new InterImpl<Interger>();
        i.show(4);
    }
}

泛型限定

？通配符。也可以理解为占位符
泛型的限定：（有点：拓展性增加，缺点：不能用具体类型的方法）
<？ extends E>：可以接受E类型或者E的子类型。上限
：可以接受E类型或者E的父类型。下限

class GenericDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> al  = new ArrayList<String>();
        
        al.add("abc01");
        al.add("abc02");
        al.add("abc03");
        ArrayList<Interger> al1 = new ArrayList<Integer>();
        al1.add(1);
        al1.add(3);
        
    }
    /*
    public static <T> void printColl(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            T t = it.next();
            System.out.println(it.next());
        }
    }
    */
    /*//泛型
    public static  void printColl(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            T t = it.next();
            System.out.println(it.next());
        }
    }
    */
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

import java.util.*;
class GenericDemo7 
{
	public static void main(String[] args) 
	{
		
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());

		ts.add(new Student("abc03"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc06"));
		ts.add(new Student("abc01"));
		
		Iterator<Student> it = ts.iterator();

		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		/**/



		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

		ts1.add(new Worker("wabc--03"));
		ts1.add(new Worker("wabc--02"));
		ts1.add(new Worker("wabc--06"));
		ts1.add(new Worker("wabc--01"));


		Iterator<Worker> it1 = ts1.iterator();

		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}

/*
class StuComp implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}

class WorkerComp implements Comparator<Worker>
{
	public int compare(Worker s1,Worker s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
*/

class Comp implements Comparator<Person>//接口文档写的是<? super E>提高了扩展性，但是只能用父类的方法
{
	public int compare(Person p1,Person p2)
	{
		return p2.getName().compareTo(p1.getName());
	}
}


class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public String toString()
	{
		return "person :"+name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}

}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

Map集合

该集合存储键值对，一对一对往里存。而且要保证键的唯一性

1、添加
    put(K key,V value)//会将原来的值返回，并覆盖原有的值。hasCode和equals判断为同一个键之后会覆盖原有的值
    putAll(Map<? extends K,? extends V> m)
2、删除
    clear()
3、判断
    containsValue(Object value)
    containsKey(Object key)
    isEmpty()
    
4、获取
    get(Object key)//不存在则返回null 
    size()
    values//集合中所有的值
    
    entrySet()
    keySet()

Map
Hashtable:底层是哈希表，不可以存入null作为值或键，该线程是同步的（效率低）
HashMap：底层是哈希表数据结构，允许使用null值和null键，线程不同步（效率高）
TreeMap：底层是二叉树结构，线程不同步，可以用于给map集合中的键进行排序

和Set很像，Set底层就是使用了Map集合

map集合的两种取出方式
1、Set keySet：将map中所有的键存入set集合，因为set具备迭代器，所以可以用迭代的方式取出所有的键，再根据get方法，获取每一个键的对应值

map集合的取出原理，将map集合转成set集合，再通过迭代器取出

2、Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

将map集合中的映射关系取出
这个关系就是Map.Entry类型
name关系对象Map.Entry获取到后，就可以通过Map.Entry中的getKey和getValue方法获取关系中的键和值

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口

Map.Entry是static接口，只有在成员方法位置上才有此修饰符
public static interface Map.entry<K,V>

interface Map//Entry是map集合中的关系，有map才有关系，Entry直接访问map的数据
{
    public static interface Entry
    {
        public abstract Object getKey();
        public abstract Object getValue();//由具体子类实现
    }
}
class HashMap implements Map
{
    class Hahs implements Map.Entry
    {
        public abstract Object getKey(){};
        public abstract Object getValue(){};
    }
}

Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entry.iterator();
while(it.hasNext())
{
    Map.Entry<String,String> me = it.next();
    String key = me.getKey();
    String value = me.getValue();
}

map例子

需求
每一个学生都有对应的归属地
学生Student，地址String
学生属性：姓名，年龄
注意：姓名和年龄相同的视为同一个学生
保证学生的唯一性

1、描述学生
2、定义map容器，将学生作为键，地址作为值，存入
3、获取map集合中的元素

import java.util.*;
class Student implements Comparable<Student//有可能存入二叉树，所以实现此接口
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Student s)
    {
        int num = new Integer(this.age).compareTo(new Integer(s.age));//默认的按照年龄份的大小进行排序，默认的排序器
        
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    public int hashCode()
    {
        returnr name.hashCode()+age*21;
    }
    public boolean equals(Object obj)
    {
        if(!obj instanceof Student)
            throw new ClassCastException("类型不匹配");
        Student s = (Student)obj;
        return this.name.equals(s.name)&&this.age==s.age;
        
    }
    public String getName()
    {
        return name;
    }
    public String getAge()
    {
        return Age;
    }
    public String toString()
    {
        return name+":"+age;
    }
}
class MapTest
{
    public static void main(Dtring[] args)
    {
        HashMap<Student,String> hm = new HashMap<Student,String>(new StuNamecomparator());//将参数传入（比较器）
        hm.put(new Student(("list1",21),"beijing");
        hm.put(new Student(("list2",22),"shanghai");
        hm.put(new Student(("list3",23),"nanjing");
        hm.put(new Student(("list4",24),"shantou");
        
        //第一种取出方式
        Set<Student> keySet = hm.keySet();
        Iterator<Student> it = keySet.iterator();
        //Iterator<Student> it = hm.keySet()iterator();
        
        while(it.hasNext())
        {
            Student stu = it.next();
            String addr = hm.get(stu);
            System.out.println(stu+":"+addr);
            
        }
        //第二种取出方式
        Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
        
        Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
        while(iter.hasNext())
        {
            Map.Entry<Student,String> me = iter.next();
            
            Student stu = me.getKey();
            String addr = me.getValue();
            System.out.println(stu+"...."+addr);
        }
         
    }
}
//自定义一个学生类的比较器
class StuNameComparator implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        return num;
    }
}

map集合练习
“dwdwdwfbuewihei”获取改字符串字母的出现的次数
希望打印结果：a[1]b[2]…

通过结果发现，没一个字母都有对应的次数
说明字母和次数之间都有映射关系时，可以选择map集合
因为map集合中存放的就是映射关系

思路：
1、将字符串转换成字符数组，因为要对每一个字母进行操作
2、定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合
3、遍历字符数组：
将没一个字母作为键去查map集合
如果返回null，将字母和1存入到map集合中
如果返回部署null，说明字母在map集合中已经存在
并有对应的次数，那么获取该次数进行自增，然后将fail字母和自增后的次数存入到map集合中，覆盖原有的值
4、将map集合中的数据变成指定的字符串形式返回

class MapTest3
{
    public static void main(String[] args)
    {
        String s = charCount("dwdafegtjyjt");
        System.out.println(s);    
    }
    public static String charCount(String str)
    {
        char[] chs = str.toCharArray();
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
        int count = 0;
        for(int x=0;x<chs.length;x++)
        {
            Integer value = tm.get(chs[x]);
            if(value !=null)
                count = calue;
            count++;
            tm.put(chs[x],count);
            count = 0;
         }
         StringBuilder sb = new StringBuilder();
         Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet)();
         Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
         
        while(it.hasNext())
        {
            Map.Entry<Character,Integer> me = it.next();
            Character ch = me.getKey();
            Integer value = me.getValue();
            sb.append(ch+value)
        }
        return sb.toString();
    }
}

Map扩展知识

map集合被使用时因为具备映射关系

import java.util.*;

class Student
{
	private String id;
	private String name;
	Student(String id,String name)
	{
		this.id = id;
		this.name = name;
	}
	public String toString()
	{
		return id+":::"+name;
	}
}
class  MapDemo3
{

	public static void demo()
	{
		HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

		List<Student> reyu = new ArrayList<Student>();
		List<Student> jiuye = new ArrayList<Student>();

		czbk.put("yureban",reyu);
		czbk.put("jiuyeban",jiuye);

		reyu.add(new Student("01","zhagnsa"));
		reyu.add(new Student("04","wangwu"));
		jiuye.add(new Student("01","zhouqi"));
		jiuye.add(new Student("02","zhaoli"));


		Iterator<String> it = czbk.keySet().iterator();

		while(it.hasNext())
		{
			String roomName = it.next();
			List<Student> room = czbk.get(roomName);
			
			System.out.println(roomName);
			getInfos(room);
		}

		

	
	}
	public static void getInfos(List<Student> list)
	{
		Iterator<Student> it = list.iterator();
		while(it.hasNext())
		{
			Student s = it.next();
			System.out.println(s);
		}
	}

	public static void main(String[] args) 
	{
		 demo();
		
		/*
		HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

		HashMap<String,String> yure = new HashMap<String,String>();
		
		HashMap<String,String> jiuye = new HashMap<String,String>();

		czbk.put("yureban",yure);
		czbk.put("jiuyeban",jiuye);


		yure.put("01","zhagnsan");
		yure.put("02","lisi");

		jiuye.put("01","zhaoliu");
		jiuye.put("02","wangwu");


		Iterator<String> it = czbk.keySet().iterator();

		while(it.hasNext())
		{
			String roomName = it.next();
			HashMap<String,String> room = czbk.get(roomName);
			
			System.out.println(roomName);
			getStudentInfo(room);
		}

		
//		getStudentInfo(jiuye);
//		getStudentInfo(yure);
*/
		
	}
	public static void getStudentInfo(HashMap<String,String> roomMap)
	{
		Iterator<String> it = roomMap.keySet().iterator();

		while(it.hasNext())
		{
			String id = it.next();
			String name = roomMap.get(id);
			System.out.println(id+":"+name);
		}
	}
}

collections-sort

用于对集合进行操作的
public static <T extends Comparable<? super T>> void sort(List list)//泛型限定，必须是Comparable的子类，因为实现排序需要进行比较

import java.util.*;
class CollectionsDemo;
{
    public sratic void main(String[] args)
    {
        
    }
    public static voif sortDemo()
    {
        List<String> list = new ArrayList<String>();//String数组已经内定实现了Comparable方法
        
        list.add("dadad");
        list.add("czfwer");
        list.add("dwdafn");
        list.add("dwavmyu");
        
        sop(list);
        
        Collections.sort(list);
        sop(list);
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);     
    }
}

工具类

按元素替换
加锁

Arrays：（用于操作数组的工具类）

asList方法：
把数组变成list集合有什么好处（可以使用集合的思想和方法操作数组）
注意：将数组变成集合不可以使用集合的增删方法，因为数组的长度是固定的。

如果增删，会发生不支持操作异常

String[] arr = {"dwda","dawdg","fsfeg"};
 List<String> list = Arrays.asList(arr)
 
 int[] nums = {2,3,4};
 List<int[]> li = Arrays.asList(nums);
 //若果数组的中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
 //如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
 //说人话就是说需要自动识别对象作为元素

集合变数组

Collection中的toArray方法

import java,util.*;
class CollectionToArray
{
    public static void main(String[] args)
    {
        ArrayList<String> a1 = new ArrayList<String>();
        a1.add("fsfe");
        a1.add("dwg");
        /*
        1、指定类型的数组到底要定义多长呢？
        当指定类型的数组长度小于集合的size，name该方法内部会创建一个新的数组，长度为集合的的size
        当指定类型的数组长度大于集合的size，就不会新创建数组，而是会传递进来的数组
        所以创建一个刚刚好的数组
        
        2、为什么要将集合变数组
        为了限定对元素的操作，不需要进行增删了
        */
        
        String[] arr = a1.toArray(new String[5]);
        
        System.out.println(Arrays.toString(arr));
        
        //高级for循环
        for(String s:a1)
        {
            System.out.println(s);
        }
    }
}

高级for循环
格式
for(数据类型 变量名：被遍历的集合（collection）或者数组)
局限性：只能对集合中的元素进行取出，但是不能对集合进行操作
传统for和高级for有什么区别？
高级for有一个局限性，必须由被遍历的目标
在遍历数组的时候，建议用传统for（因为有角标）

jdk1.5新特性

可变参数
其实是数组的简写形式
不用每一次都手动的加你数组对象
只要将要操作的元素作为参数传递即可
隐式将这些参数封装成了数组
注意：使用时可变参数一定要定义在参数列表的后面

main()
{
    show(2,345,674);   
}
public stasic void show(int... arr)//可变参数
{
    System,out.println(arr.length);
}

静态导入
import static java.util.Arrays.;//导入Arrays这个类中所有的静态成员
import static java.lang.System.;//导入了system中的所有静态成员
当类名重名时，要指定具体的报名
当方法重名时，指定具备所属的对象或者类