• 热门专题

Java基础:集合框架

作者:  发布日期:2016-10-11 19:55:15
Tag标签:框架  基础  

  • 1.集合框架概述及其特点

    面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式; 数组和集合都是容器,相较于数组有以下特点: (1).集合的长度是可变的;数组的长度是固定的; (2).集合只能存储对象,即引用数据类型,存放的都是对象的引用/地址;数组可以存储基本数据类型; (3).集合可以存储不同类型的对象;数组存储的是同一类型的数据或对象;

    2.Java中的集合体系

    每一个容器对数据的存储方式都有不同,这样的存储方式称之为:数据结构;

    Interface Collection

    |--Interface List:元素是有序的,有序的意思是按什么顺序存储就按什么顺序读取,元素可以重复,因为集合List体系有索引;

    |--ArrayList:底层数据结构是数组结构,查找速度快,增删操作复杂,线程不同步;

    |--LinkedList:底层数据结构是链表结构,查找速度较慢,增删操作快;

    |--Vector:底层数据结构是数组结构,线程同步的,集合框架出现后被ArrayList取代;

    |--Interface Set:元素是无序的(存入和取出的顺序不一致),元素不可以重复;

    |--HashSet:底层数据结构是哈希表,保证元素惟一性通过hashCode()和equals()方法;

    |--TreeSet:底层数据结构是二叉树,可以对Set集合中的元素进行排序;

    Interface Map:该集合存储键值对,保证键的唯一性;

    |--Hashtable:底层数据结构是哈希表,不可以存入null的键和值,线程同步的,元素间无序;

    |--HashMap:底层数据结构是哈希表,允许使用null的键和值,线程不同步,效率高,元素间无序;

    |--TreeMap:底层数据结构是二叉树,线程不同步,可以用于给Map集合中的键排序;

    3.共性的Collection集合

    (1).添加元素: boolean add (Object obj):添加某个元素,操作成功返回true; boolean addAll(Collection c):添加某个集合,相当于并集; (2).删除元素: void clear():移除此Collection中的所有元素; boolean remove(Object obj):从该Collection中移除指定元素的单个实例;删除成功返回true; boolean removeAll(Collection c):移除在该Collection中那些也包含在指定c中的所有元素,相当于取差集; (3).获取操作: int size():返回元素个数; boolean retainAll(Collection c):仅保留此Collection中那些也包含在指定c中的元素,相当于取交集; (4).判断操作: boolean contains(Object obj):判断是否包含指定元素; boolean containsAll(Collection c):此Collection中包含指定c中的所有元素时,返回true; boolean isEmpty():判断是否为空集合; (5).转换操作: Object[ ] toArray():集合转换为数组; (6).获取元素: Iterator iterator():返回在此Collection的元素上进行迭代的迭代器; 迭代器:集合的取出元素方式; 其产生:每个集合中都有取出操作,当简单的方法不足以完成取出动作时,就将取出的动作封装成一个对象,又由于不同数据结构的集合的取出操作各有差异,但是取出的动作通常是共性的(判断+取出),于是向上抽取定义取出集合元素操作的内部类;之所以定义为内部类,是因为取出的操作需要操作的是集合中的元素,因此定义为内部类来直接访问集合中的元素最为方便; 将这些内部类符合的规则定义为Iterator; 联系:夹娃娃机;整个机器相当于容器集合,保存的元素是娃娃;内部类相当于夹子,定义在机器内部;外部的操纵杆相当于集合对外提供的方法; 集合的迭代操作:
    package com.zr.day14;
    
    import java.util.*;
    
    class IteratorDemo
    {
    	public static void main(String[] args)
    	{
    		Collection c = new ArrayList();//定义一个集合
    		c.add("Messi");		//添加一些元素
    		c.add("Ronaldo");
    		c.add("kaka");
    		c.add(100);
    		
    		Iterator it = c.iterator();//迭代获取
    		while(it.hasNext())
    		{
    			System.out.println(it.next());
    		}
    		System.out.println("------------");
    		
    		//for循环对资源的释放处理更优化;
    		for(Iterator iter = c.iterator();iter.hasNext();)
    		{
    			System.out.println(iter.next());
    		}
    	}
    }

     

    4.List集合

    4.1 List集合中的特有方法

    因为List集合是有序的,所以相较于Collection,带有角标的方法都是List集合的特有方法; (1).增 void add(int index, Object obj):在指定位置添加元素; boolean addAll(int index, Collection c):将指定集合添加到指定位置; (2).删 Object remove(int index):移除列表中指定位置的元素,返回以前再此位置的元素; (3).改 Object set(int index, Object obj):用指定元素替换列表中指定位置的元素,返回之前的元素; (4).查 Object get(int index):返回列表中指定位置的元素; List subList(int fromindex, int toindex):返回子列表,包含头不包含尾; int indexOf(Object obj):返回列表中第一次出现的指定元素的索引,没有则返回-1; int lastIndexOf(Object obj):反向索引; (5).特有的获取元素迭代器 ListIterator listIterator():迭代 ListIterator listIterator(int index):从指定位置开始迭代 (6).迭代器Iterator和列表迭代器ListIterator ListIterator继承了Iterator,是其子接口; 在迭代集合时,使用Iterator中操作元素的方法有限; Iterator:hasNext(),next(),remove(); ListIterator:hasNext(),next(),nextIndex(),remove(),add(),set(),hasPrevious(),PreviousIndex(),Previous(); 并发操作异常:迭代器操作和集合操作同时处理集合中的元素;ConcurrentModificationException; (7).多种获取List集合元素的方式;
    package com.zr.day14;
    
    import java.util.*;
    
    class IteratorDemo
    {
    	public static void main(String[] args)
    	{
    		ArrayList al = new ArrayList();
    		al.add("Messi");
    		al.add("Ronaldo");
    		al.add("kaka");
    		al.add(100);
    		
    		//方式一:使用角标操作,循环遍历;
    		for(int x=0; x<al.size(); x++)
    		{
    			System.out.println(al.get(x));
    		}
    		System.out.println("------------");
    		
    		//方式二:使用集合迭代器Iterator;
    		Iterator it = al.iterator();
    		while(it.hasNext())
    		{
    			System.out.println(it.next());
    		}
    		System.out.println("------------");
    		
    		//方式三:使用列表迭代器ListIterator;
    		//在迭代操作时还可以对集合中元素进行多种操作;
    		ListIterator lit = al.listIterator();
    		while(lit.hasNext())
    		{
    			System.out.println(lit.next());
    		}
    	}
    }


    4.2 List:ArrayList

    ArrayList底层数据结构是数组,大多数方法都和List接口一致; 特有方法:protected void removeRange(int fromIndex, int toIndex):移除索引范围内的元素;包含头不包含尾 (1).去除ArrayList集合中的重复字符串元素;
    //定义一个功能用来去除列表中的重复字符串元素;
    package com.zr.day14;
    
    import java.util.*;
    
    class ArrayListDemo
    {
    	public static void main(String[] args)
    	{
    		//新建一个列表,添加元素;
    		ArrayList al = new ArrayList();
    		al.add("Messi");
    		al.add("Ronaldo");
    		al.add("Bale");
    		al.add("kaka");
    		al.add("Ronaldo");
    		//ArrayList中复写了toString方法;
    		System.out.println(al);
    		//去除重复字符串;
    		al = removeOther(al);
    		System.out.println(al);
    	}
    	
    	//返回值类型:可以将新的ArrayList赋值给原ArrayList;
    	//参数列表:原ArrayList;
    	public static ArrayList removeOther(ArrayList al)
    	{
    		ArrayList newAl = new ArrayList();
    		Iterator it = al.iterator();
    		//迭代
    		while(it.hasNext())
    		{
    			Object obj = it.next();
    			//判断新列表中是否已经存在该对象;
    			if(!newAl.contains(obj))
    			{
    				//如果不存在则将该对象添加到新列表
    				newAl.add(obj);
    			}
    		}
    		//返回新列表
    		return newAl;
    	}
    }


    (2).将自定义对象作为元素存储到ArrayList集合中,并去除重复元素;
    //定义一个功能用来去除自定义对象中的重复元素;
    //自定义的是Student对象,当两个Student对象的name属性和age属性都相同时,判定这两个对象是重复元素;
    package com.zr.day14;
    
    import java.util.*;
    
    class ArrayListDemo
    {
    	public static void main(String[] args)
    	{
    		//新建一个列表,添加元素;
    		ArrayList al = new ArrayList();
    		al.add(new Student("Messi",26));
    		al.add(new Student("Ronaldo",27));
    		al.add(new Student("Bale",28));
    		al.add(new Student("kaka",29));
    		al.add(new Student("Ronaldo",27));
    		al.add(new Student("Ronaldo",30));
    		//ArrayList中复写了toString方法;
    		System.out.println("处理前:"+al);
    		//去除重复字符串;
    		al = removeOther(al);
    		System.out.println("处理后:"+al);
    	}
    	
    	//返回值类型:可以将新的ArrayList赋值给原ArrayList;
    	//参数列表:原ArrayList;
    	public static ArrayList removeOther(ArrayList al)
    	{
    		ArrayList newAl = new ArrayList();
    		Iterator it = al.iterator();
    		//迭代
    		while(it.hasNext())
    		{
    			Object obj = it.next();
    			//判断新列表中是否已经存在该对象;
    			if(!newAl.contains(obj))
    			{
    				//如果不存在则将该对象添加到新列表
    				newAl.add(obj);
    			}
    		}
    		//返回新列表
    		return newAl;
    	}
    }
    //自定义的Student对象;
    class Student
    {
    	private String name;
    	private int age;
    	Student(String name, int age)
    	{
    		this.name = name;
    		this.age = age;
    	}
    	//覆盖toString()方法;
    	public String toString()
    	{
    		return name+":::::"+age;
    	}
    	//覆盖equals()方法;
    	public boolean equals(Object obj)
    	{
    		if(!(obj instanceof Student))
    			return false;
    		Student stu = (Student)obj;
    		boolean b = this.name.equals(stu.name) && this.age == stu.age;
    		//添加的打印语句分析比较过程
    		System.out.println(this.name + "--比较--" + stu.name + "--结果--::" +b);
    		return b;
    	}
    }

    输出结果:
    分析打印结果发现,ArrayList的contains()方法底层是通过调用equals方法来比较各个元素是否是重复元素;

    4.3 List:Vector

    Vector是集合框架之前的体系,底层数据结构也是数组,集合框架出现后被ArrayList所替代; Vector中的获取元素方法:角标,迭代器,枚举; 其中枚举是Vector的特有方式,因为枚举的名称和方法名称都过长,最后被迭代器所取代; Enumeration elements():相当于集合中的iterator方法; Interface Enumeration中封装的方法: boolean hasMoreElements():使用时相当于Iterator中的hasNext()方法; Object nextElement():使用时相当于Iterator中的next()方法;

    4.4 List:LinkedList

    LinkedList底层数据结构是链表结构,相较于数组结构的ArrayList有其特有的方法; (1).添加: void addFirst(Object obj) void addLast(Object obj) boolean offer(Object obj) boolean offerFirst(Object obj) boolean offerLast(Object obj) (2).删除: Object removeFirst() Object removeLast() Object poll() Object pollFirst() Object pollLast() (3).获取: Object getFirst() Object getLast() Object peek() Object peekFirst() Object peekLast() (4).逆向迭代 Iterator descendingIterator() 上述方法中,offer,peek,poll方法是JDK6.0之后出现的,当集合中没有元素时不会抛出异常,直接返回null; 但是get和remove方法会出现异常:NoSuchElementException; (5).练习:使用LinkedList创建栈和队列数据结构;
    /*
     * 使用LinkedList构建栈和队列数据结构;
     */
    package com.zr.day14;
    
    import java.util.LinkedList;
    
    class LinkedListDemo
    {
    	public static void main(String[] args)
    	{
    		MyQue mq = new MyQue();
    		mq.myAdd("messi");
    		mq.myAdd("ronaldo");
    		mq.myAdd("kaka");
    		System.out.println(mq);
    		System.out.println(mq.myDel());
    		System.out.println(mq);
    	}
    }
    //队列的存储规律:先进先出
    //使用LinkedList实现具体是实现在其一端进行元素的添加,在另一端进行元素的删除
    class MyQue
    {
    	private LinkedList ll;
    	MyQue()
    	{
    		this.ll = new LinkedList();
    	}
    	//添加元素
    	public void myAdd(Object obj)
    	{
    		ll.addFirst(obj);
    	}
    	//删除元素
    	public Object myDel()
    	{
    		return ll.removeLast();
    	}
    	//打印输出
    	public String toString()
    	{
    		return ll.toString();
    	}
    }
    
    //栈的存储规律:先进后出
    //使用LinkedList实现具体步骤是封装只在某一端进行添加和删除元素的方法;
    class MyStack
    {
    	private LinkedList ll ;
    	MyStack()
    	{
    		this.ll = new LinkedList();
    	}
    	//添加元素的方法
    	public void myAdd(Object obj)
    	{
    		ll.addFirst(obj);
    	}
    	//删除元素的方法,删除后同时返回被删除的元素;
    	public Object myDel()
    	{
    		return ll.removeFirst();
    	}
    	//打印输出的复写
    	public String toString()
    	{
    		return ll.toString();
    	}
    }

     

    5.Set集合

    Set作为Collection集合的子类,其中的操作基本同Collection集合一致,相较于List集合,其存取是无序的;

    5.1 HashSet

    分析HashSet中如何保证元素的惟一性: 首先,因为HashSet底层数据结构是哈希表,所以对于添加的元素,会计算该对象的哈希值,即hashCode()方法,当哈希值不一样时,就根据哈希表为元素分配不同的地址空间;当哈希值一样时,再通过比较equals()方法确定对象是不是同一对象,如果是则为了保证唯一性,只保留一个元素,如果不是则在该哈希值对应的地址域再分配空间存储元素; 说明: (1).基类Object: hashCode():根据地址值返回一个整数; equals():当两个引用指向同一个对象时,返回true; toString():obj.getClass().getName() + "@" +hashCode(); (2).String类:该类中复写了上述方法; hashCode():根据字符串的内容返回一个整数; equals():当两个字符串序列一致时,返回true; toString():返回字符串本身; (3).其他自定义类,当需要存储到HashSet集合中的时候应尽量覆盖hashCode()和equals()方法; 实例: (1).使用HashSet存储字符串对象;
    //使用HashSet存储字符串对象;
    package com.zr.day14;
    
    import java.util.HashSet;
    
    class HashSetDemo
    {
    	public static void main(String[] args)
    	{
    		HashSet hs = new HashSet();
    		System.out.println(hs.add("messi"));
    		System.out.println(hs.add("kaka"));
    		System.out.println(hs.add("bale"));
    		//返回false,存储失败;
    		//String类中复写了hashCode()方法和equals()方法,所以保证了元素的唯一性;
    		System.out.println(hs.add("messi"));
    		
    		System.out.println(hs);//可以看出结果是无序的;
    	}
    }


    (2).使用HashSet存储自定义对象;
    //使用HashSet存储自定义对象;
    package com.zr.day14;
    
    import java.util.HashSet;
    
    //自定义Person对象
    class Person
    {
    	private String name;
    	private int age;
    	Person(String name,int age)
    	{
    		this.name = name;
    		this.age = age;
    	}
    	//覆盖hashCode方法;
    	public int hashCode()
    	{
    		//根据对象的实际属性内容来获取哈希值;
    		return this.name.hashCode()+this.age*38;
    	}
    	//覆盖equals方法;
    	public boolean equals(Object obj)
    	{
    		if(!(obj instanceof Person))
    			return false;
    		Person p = (Person)obj;
    		boolean b = this.name.equals(p.name) && this.age == p.age;
    		System.out.println(this.name+"--比较--"+p.name +"--结果--"+b);
    		return b;
    	}
    	//覆盖toString方法;
    	public String toString()
    	{
    		return this.name+"::"+this.age;
    	}
    }
    
    class HashSetDemo
    {
    	public static void main(String[] args)
    	{
    		HashSet hs = new HashSet();
    		hs.add(new Person("p1",21));
    		hs.add(new Person("p2",22));
    		hs.add(new Person("p3",23));
    		hs.add(new Person("p2",22));
    		hs.add(new Person("p3",23));
    		
    		System.out.println(hs);
    	}
    }

    通过上述示例可以看出,每当新添加一个对象时,会计算这个对象的哈希值,同已有的对象哈希值进行比较,如果哈希值相等,则再调用equals方法判断是否是同一个对象; 代码运行结果:
    总结:在HashSet中是通过hashCode()和equals()方法来保证元素的惟一性的,而且这两个方法还作为判断操作和删除操作的依据,所以对于自定义的对象,要覆盖这两个方法;

    5.2 TreeSet

    TreeSet相较于HashSet,其底层使用的是二叉树的数据结构,可以对集合中的元素进行排序; 排序的两种方式: (1).使TreeSet中的元素自身具备比较性; 实现Java.lang.Comparable接口,覆盖接口中定义的int compareTo(Object o)方法; 比较时,当主要条件相同时,必须要判断次要条件; 保证元素惟一性的依据:compareTo(); 元素对象被定义完成就具备比较性,这种顺序称为元素的自然顺序,或者叫默认顺序; String类实现了Comparable接口,其自然顺序是字典顺序; 同样,基本数据类型包装类也实现了Comparable接口; 自定义类如果要存放到TreeSet集合中需要实现Comparable接口; (2).让集合自身具备比较性:将自定义的比较器传递给集合的构造方法; Java.util.Comparator接口中定义了int compare(Object o1, Object o2)方法; 当元素自身不具备比较性时,或者具备的比较性不是实际环境所需要的,就可以使用自定义的比较器; 在集合初始化的时候就定义了比较方式;
    示例: (1).使用TreeSet存储字符串对象;
    //使用TreeSet存储字符串对象,验证其排序共能;
    package com.zr.day14;
    
    import java.util.Comparator;
    import java.util.TreeSet;
    
    class TreeSetDemo
    {
    	public static void main(String[] args)
    	{
    		//将自定义的比较器作为参数传递给TreeSet的构造方法,是集合一初始化就具备比较性
    		TreeSet ts = new TreeSet(new MyComparator());
    		ts.add("ggxd");
    		ts.add("mmn");
    		ts.add("abc");
    		ts.add("zz");
    		//String类实现了Comparable接口,覆盖了compareTo()方法,保证了元素的唯一性;
    		ts.add("zz");
    		//输出结果按照字符串的字典顺序排列;
    		System.out.println(ts);
    	}
    }
    //自定义一个比较器按照字符串的长度进行排序
    //实现java.util.Comparator接口
    class MyComparator implements Comparator
    {
    	//覆盖compare方法
    	public int compare(Object o1, Object o2) 
    	{
    		//强制类型转换
    		String s1 = (String)o1;
    		String s2 = (String)o2;
    		//基本数据类型包装类实现了comparable接口,因此可以封装后调用compareTo接口;
    		int num = Integer.valueOf(s1.length()).compareTo(Integer.valueOf(s2.length()));
    		if(num==0)
    			//当主要条件相同时,必须要比较次要条件;
    			//按字符串的字典顺序;
    			return s1.compareTo(s2);
    		return num;
    	}
    	
    }


    (2).使用TreeSet存储自定义对象;
    //使用TreeSet存储自定义对象;
    package com.zr.day14;
    
    import java.util.*;
    
    class TreeSetTest
    {
    	public static void main(String[] args)
    	{
    		//使用匿名内部类自定义一个比较器
    		//主要的比较方式是按照name的长度比较,次要的比较方式是按照age从大到小;
    		TreeSet ts = new TreeSet(new Comparator()
    		{
    			public int compare(Object o1, Object o2)
    			{
    				Person p1 = (Person)o1;
    				Person p2 = (Person)o2;
    				int num = Integer.valueOf(p1.getName().length()).compareTo(Integer.valueOf(p2.getName().length()));
    				if(num==0)
    					return Integer.valueOf(p2.getAge()).compareTo(Integer.valueOf(p1.getAge()));
    				return num;
    			}
    		});
    		ts.add(new Person("alonsol",30));
    		ts.add(new Person("messi",29));
    		ts.add(new Person("messi",27));
    		ts.add(new Person("bale",21));
    		ts.add(new Person("zidane",25));
    
    
    		System.out.println(ts);
    	}
    }
    //自定义Person对象,定义其自然顺序
    //实现Comparable接口,复写compareTo方法;
    class Person implements Comparable 
    {
    	private String name;
    	private int age;
    	Person(String name,int age)
    	{
    		this.name = name;
    		this.age = age;
    	}
    	
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String toString()
    	{
    		return this.name+"::"+this.age;
    	}
    
    	//主要排序方式是按照name的字典顺序,次要的排序是按照age的从小到大;
    	public int compareTo(Object o){
    		if(!(o instanceof Person))
    			throw new ClassCastException("转换异常");
    		Person p = (Person)o;
    		int num = this.name.compareTo(p.name);
    		if(num==0)
    			return Integer.valueOf(this.age).compareTo(Integer.valueOf(p.age));
    		return num;
    	}
    }
    

     

    6.Map集合

    Map集合中存储的是键值对,而且保证键的惟一性;

    6.1 Map集合中的共性方法

    (1).添加操作 Object put(Object key, Object value):要么返回null,要么返回该key对应的之前的值; void putAll(Map m) (2).删除操作 Object remove(Object key):根据键查找移除,返回该键对应的value void clear():清空集合 (3).判断操作 boolean containKey(Object key):判断键; boolean containValue(Object value):判断值 boolean isEmpty():判断集合是否为空; (4).获取操作 Object get(Object key):根据键获取值; int size():获取集合大小; Collection values():获取value的集合;

    6.2 Map集合中的迭代操作

    因为Map集合中没有定义迭代器,所以要取出Map集合中的元素只有利用Set集合的迭代器; (1).方式一:set keySet() 将Map中的所有键存储到Set集合中,在利用Set集合的迭代器,使用迭代方式获取所有键,然后调用Map集合中的get方法,获取每个键对应的value值; (2).方式二:set<Map.Entry<k,v>> entrySet() 使用entrySet方法返回的是集合键与值之间的映射关系结合,关系的类型是Map.Entry类型,该类是Map接口中的一个静态内部接口,其中定义了getKey(),getValue(),setValue()等方法,通过这些方法同样可以获取Map集合中的键和值; 内部接口中只提供了方法的定义,具体的实现由Map的子类去实现;
    package com.zr.day14;
    import java.util.*;
    //自定义对象,和所在城市信息,使用Map集合存储;
    class MapDemo
    {
    	public static void main(String[] args)
    	{
    		HashMap<Stu,String> hm = new HashMap<Stu,String>();
    		//Map中添加元素的方法是put;
    		hm.put(new Stu("zxx",38),"北京");
    		hm.put(new Stu("lhm",15),"上海");
    		hm.put(new Stu("mesi",54),"武汉");
    		hm.put(new Stu("hua",76),"深圳");
    		hm.put(new Stu("hua",36),"深圳");
    		
    		//方式一:keySet方式
    		Set<Stu> ks = hm.keySet();
    		Iterator<Stu> it = ks.iterator();
    		while(it.hasNext())
    		{
    			Stu stu = it.next();
    			String city = hm.get(stu);
    			System.out.println(stu + "-----" + city);
    		}
    		
    		//方式二:entrySet方式
    		Set<Map.Entry<Stu,String>> es = hm.entrySet();
    		Iterator<Map.Entry<Stu,String>> iter = es.iterator();
    		while(iter.hasNext())
    		{
    			Map.Entry<Stu,String> me = iter.next();
    			Stu stu = me.getKey();
    			String city = me.getValue();
    			System.out.println(stu + "********" + city);
    		}
    	}
    }
    //自定义Stu对象,因为不确定要存储到什么类型的集合中;
    //所以复写其hashCode()方法和equals()方法保证其唯一性;
    //实现Comparable接口复写compareTo()方法,设置其自然顺序;
    class Stu implements Comparable<Stu>
    {
    	private String name;
    	private int age;
    	public Stu(String name,int age)
    	{
    		this.name = name;
    		this.age = age;
    	}
    	public int hashCode()
    	{
    		return this.name.hashCode() + (this.age * 38);
    	}
    	public boolean equals(Object o)
    	{
    		if(!(o instanceof Stu))
    			throw new ClassCastException("类型不匹配");
    		Stu stu = (Stu)o;
    		return this.name.equals(stu.name) && this.age == stu.age;
    	}
    	public int compareTo(Stu stu)
    	{
    		int num = this.name.compareTo(stu.name);
    		if(num==0)
    			return Integer.valueOf(this.age).compareTo(Integer.valueOf(stu.age));
    		return num;
    	}
    	public String toString()
    	{
    		return this.name+":"+this.age;
    	}
    }

    (3).练习:根据给定的字符串按照指定的格式打印字符和字符个数;
    //根据指定字符串按照指定格式打印字符和字符的个数;
    //指定字符串:“abcabcabcabdabef”
    //打印格式:a()b()c()...
    //步骤:
    //1.将字符串转换策划那个字符数组
    //2.定义一个Map集合用来存储映射关系
    //3.遍历字符数组
    //4.将Map集合中的数据变成指定的字符串形式返回
    package com.zr.day14;
    import java.util.*;
    class MapTest
    {
    	public static void main(String[] args)
    	{
    		String str = "abcabc2abcabdabef";
    		String pri = printMap(str);
    		System.out.println(pri);
    	}
    	public static String printMap(String str)
    	{
    		//字符串转化为字符数组
    		char[] chs = str.toCharArray();
    		//定义Map集合
    		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
    		int count = 0;
    		//遍历
    		for(int x=0; x<chs.length; x++)
    		{
    			//筛选字符
    			if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
    				continue;
    			Integer value = tm.get(chs[x]);
    			if(value != null)
    				count = value;
    			tm.put(chs[x], ++count);
    			count=0;
    		}
    		
    		Set<Character> ks = tm.keySet();
    		Iterator<Character> it = ks.iterator();
    		StringBuilder sb = new StringBuilder();
    		while(it.hasNext())
    		{
    			Character ch = it.next();
    			Integer value = tm.get(ch);
    			//按照指定格式
    			sb.append(ch+"("+value+")");
    		}
    		return sb.toString();
    	}
    }


    6.3 Map集合扩展;集合嵌套;

    7. 集合框架中的工具类

    7.1 Collections:提供了很多用来操作集合的方法;

    (1).sort(list):用来给List集合排序,可以指定比较器,Set中可以直接使用TreeSet;

    (2).max,min:用来获取集合中的最值元素,可以使用默认顺序可以使用自定义比较器;

    (3).int binarySearch(list, key):二分查找,针对有序的集合,返回值-(插入值)-1;

    (4).void fill(list, object):将集合中的所有元素替换为指定元素;

    (5).boolean replaceAll(list , old, new):使用新值替换列表中出现的所有某一指定值;

    (6).void reverse (list):反转列表中的元素;

    (7).Comparator reverseOrder():反转默认顺序的比较器;

    (8).Comparator reverseOrder(comparator):反转指定比较器顺序;

    (9).void shuffle(list):随机排列

    (10).List synchronizedList(list):返回线程同步的列表;

    (11).void swap(list,i,j):交换指定位置的元素;

    7.2 Arrays:专门用来操作数组的工具类;

    (1).二分查找

    (2).排序

    (3).填充fill

    (4).List asList(可变参数):将数组转换为列表;

    数组转变为集合:

    asList,将数组转换为集合,可以使用集合的思想和方法操作数组;

    但是,不可以使用集合的增删方法,因为数组的长度是固定的;否则会出现UnSupportedOperationException;

    数组中的元素都是对象的引用时,那么数组中的元素就直接转换为集合中的元素;

    数组中的元素是基本数据类型时,那么就将整个数组作为集合中的元素;

    集合转变为数组:

    Collection中提供的toArray()和toArray(object[ ] array)操作可以完成集合到数组的转换;

    集合转换为数组,主要是限定对集合元素的操作;

    当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新数组,长度为集合的size;

    当指定类型的数组长度大于集合的size,使用原来的数组;

    最好是指定大小刚刚好的数组:size();

    8.其他常用对象

    8.1 System (1).对外没有提供构造函数,不能被实例化; (2).该类中定义的方法都是静态的; (3).操作属性:Properties是Hashtable的子类
    getProperties():获取系统属性; setProperties():设置系统属性; list(PrintStream):可以将属性信息输出到指定的输出流;
    8.2 Runtime

    每个Java应用程序都有一个Runtime实例,应用程序执行时就建立了;

    (1).没有构造函数,也就不能new对象,可以通过getRuntime()获取Runtime对象(单例);

    (2).方法ecex()可以用来执行一个命令,返回一个Process类型对象;

    8.3 Math:java.lang

    (1).ceil():大于指定值的最小整数;

    (2).floor():小于指定值的最大整数;

    (3).round():四舍五入;

    (4).pow(底数,指数):求幂;

    (5).random():返回0到1之间的随机double数,包含0不包含1;

     
About IT165 - 广告服务 - 隐私声明 - 版权申明 - 免责条款 - 网站地图 - 网友投稿 - 联系方式
本站内容来自于互联网,仅供用于网络技术学习,学习中请遵循相关法律法规