java 树层级遍历 java treemap遍历

1 TreeMap的两种遍历方式

     思路1：键值对对象找键和值方式

         entrySet()方法：获取键值对对象 ,把键和值封装起来看做一个对象
 1）获取所有键值对对象的集合---entrySet()方法
 2）遍历键值对对象的集合，获取到每一个键值对对象---foreach遍历
 3）根据键值对的得到键和值---getKey()和getValue()方法
    思路2：键找值方式
 1）获取所有键的集合----keySet()
 2）遍历键的集合，获取到每一个键---foreach遍历→注意判断是否非空
 3）根据键找值----get(K key)→value
实例1

 

package demo;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/**
 * @author Orange
 * @version 1.8
 */
// 测试类
public class Test01 {
	public static void main(String[] args) {
		TreeMap<Integer, Student> tm = new TreeMap<Integer, Student>();
		method1(tm);//方式1
		System.out.println("---------------");
		method2(tm);//方式2
		tm.put(1, new Student("小花", 18));
		tm.put(2, new Student("小兰", 17));
		tm.put(3, new Student("阿迪", 19));
		/**
		 * 思路：将集合转化为数组进行遍历
		 * 错误：Map是双列集合，无法直接转换成toArray形式
		 * 此种思路pass
		 */
		
	}

	/**
	 * @param tm
	 *     方式2---利用TreeMap本身的keySet得到键对象，进而用get(K key)得到值对象
	 */
	private static void method2(TreeMap<Integer, Student> tm) {
		tm.put(1, new Student("小花", 18));
		tm.put(2, new Student("小兰", 17));
		tm.put(3, new Student("阿迪", 19));
		/*
		 * for(<Integer, Student> s:tm){
			System.out.println(s);
		}
		错误：原来想通过这种方式，遍历元素
		只有通过键值对的方法才能遍历
		*/
		Set<Integer> keySet = tm.keySet();
		/** 
		 * 思路2：-----键找值方式
		 * 1)获取所有键的集合----keySet()
		 * 2)遍历键的集合，获取到每一个键---foreach遍历
		 * 3)根据键找值----get(K key)→value
		 * */
		for(Integer integer:keySet){
			System.out.println(integer);
			Student student = tm.get(integer);
			System.out.println("\t"+student.getName()+"---"+student.getAge());
		}
	}

	/**
	 * @param tm
	 *       方式1--利用entrySet()方法去遍历Map集合中的元素
	 */
	private static void method1(TreeMap<Integer, Student> tm) {
		tm.put(1, new Student("阿花", 18));
		tm.put(2, new Student("阿兰", 17));
		tm.put(3, new Student("阿迪", 19));
		Set<Entry<Integer, Student>> es = tm.entrySet();//重要！！！
		/**
		 * 思路1：---值对对象找键和值方式
		 * entrySet()----键值对对象 ,把键和值封装起来看做一个对象
		 * 1）获取所有键值对对象的集合---entrySet()方法
		 * 2）遍历键值对对象的集合，获取到每一个键值对对象---foreach遍历
		 * 3）根据键值对的得到键和值---getKey()和getValue()方法
		 */
		for(Entry<Integer, Student> e:es){
			System.out.println(e.getKey());
			Student student = e.getValue();
			/**
			 * 原来错误思路：对获取的键值竟然妄想去用foreach遍历
			 * foreach遍历：集合或数组
			 * 哎，差得码子大！！！
			 */
			System.out.print("\t"+student.getName()+"---"+student.getAge()+"\r");
		}
	}
}

说明：将两种方法分别封装到方法里面

 

2  HashMap和TreeMap的get()方法的应用

实例2

 

package demo;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/**
 * @author Orange
 * @version 1.8
 */

public class Test02 {
	/**
	 * 
	 * 练习1：需求：统计字符串中每个字符出现的次数----HashMap
	 * "aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
	 * 练习2：需求：将字符串中的字符按照先后a-z的方式进行排序----TreeMap
	 * 如果bdadabcc-----结果：a(2)b(2)c(2)d(2)
	 */
	/**
	 * 分析：分析字符串，再观察字符串要求的结果，里面为每个字出现的次数
	 * 大方法思路：创建一个StringBuilder的对象利用append()方法拼接字符'('和')'和次数
	 * 用集合的观点看世界。。。
	 * 通过观察有点像键值对(除了'('和')')，既然决定用键值对，关键是如何如何统计次数
	 * 技巧：通过get()方法的返回值对字符进行计数
	 */
	//1---创建键盘录入对象，输入字符串----字符字符串
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串：");
		String reStr = sc.nextLine();
		//由于是要对字符串中的字符进行计数，转化成字符数组
		char[] charArray = reStr.toCharArray();
		//创建一个集合容器保存键值对对象---字符和对应次数
		exercise1(charArray);//练习1
		exercise2(charArray);//练习2
	}

	/**
	 * @param charArray
	 */
	private static void exercise2(char[] charArray) {
		//由于要进行排序--TreeMap集合
		TreeMap<Character, Integer> tm = new TreeMap<Character,Integer>();
		if(charArray!= null){
			for(char c:charArray){
				//用集合的get()方法判断集合中是否已经有该字符对象
				if(tm.get(c)==null){
					tm.put(c, 1);//如果为null,表示还没有此值对象，将value设置为1
				}else{
					//如果不为null,表示集合中已经有该值对象对应的键对象，只需要对值对象做改变
					Integer value = tm.get(c);//得到当前键的值对象，重新赋值
					tm.put(c, ++value);
				}
			}
		}
		//好了,关键的地方已经弄的差不多了，该创建字符串缓冲区对象了
		//创建StringBuilder的对象
		StringBuilder sb = new StringBuilder();
		//需要对HashMap集合中的键和值遍历出来用append()拼接
		//首先得到"键值对"对应的键和值
		Set<Entry<Character, Integer>> es = tm.entrySet();
		if(es!=null){//foreach缺点：---所以必须进行非空判断
			for(Entry<Character, Integer> s:es){
				//得到键值对对象的键
				Character key = s.getKey();
				//得到键对应的值
				Integer value = s.getValue();
				//下面就是拼接了
				sb.append(key).append("(").append(value).append(")");
			}
		}
		System.out.println(sb);
	}

/**
 * @param charArray
 */
private static void exercise1(char[] charArray) {
	HashMap<Character, Integer> hm = new HashMap<Character,Integer>();
	//对字符数组的字符进行遍历---foreach
	if(charArray!= null){
		for(char c:charArray){
			//用集合的get()方法判断集合中是否已经有该字符对象
			if(hm.get(c)==null){
				hm.put(c, 1);//如果为null,表示还没有此值对象，将value设置为1
			}else{
				//如果不为null,表示集合中已经有该值对象对应的键对象，只需要对值对象做改变
				Integer value = hm.get(c);
				hm.put(c, ++value);
			}
		}
	}
	
	
	//好了,关键的地方已经弄的差不多了，该创建字符串缓冲区对象了
	//创建StringBuilder的对象
	StringBuilder sb = new StringBuilder();
	//需要对HashMap集合中的键和值遍历出来用append()拼接
	//首先得到"键值对"对应的键和值
	Set<Entry<Character, Integer>> es = hm.entrySet();
	if(es!=null){//foreach缺点：---所以必须进行非空判断
		for(Entry<Character, Integer> s:es){
			//得到键值对对象的键
			Character key = s.getKey();
			//得到键对应的值
			Integer value = s.getValue();
			//下面就是拼接了
			sb.append(key).append("(").append(value).append(")");
		}
	}
	System.out.println(sb);
 }
}

说明：代码的冗余度较高，为方便说明，不再简写

 

 

 

3  集合嵌套

 

 3.1集合嵌套之HashMap嵌套ArrayList-----HashMap存储的是ArrayList类型元素

 以如下的方式在控制台打印：
       巨星
               林正英 18
               李小龙 24
一线明星
               冯绍峰 20
               黄海波 24

练习1  Student类

 

package demo;

/**
 * @author Orange
 * @version 1.8
 */
public class Student {
	private String name;
	private int age;

	public Student() {
		super();
		
	}

	public Student(String name, int age) {
		super();
		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;
	}

}

 

测试类

 

package demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

/**
 * @author Orange
 * @version 1.8
 */
public class Demo03 {
	/*	
	分析：HashMap键值对存储元素	
	思考：由于java的Map类中允许"值对象"也是Map类型的
	做法：可以将"林正英---18"以键值对的形式来表示，此时不需要Student类了，感兴趣可以自己尝试一下		
	*/
	public static void main(String[] args) {
		//创建两个ArrayList----容器
		ArrayList<Student> al1 = new ArrayList<Student>();
		//储存元素，匿名内部类
		al1.add( new Student("林正英",18));
		al1.add( new Student("李小龙",24));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		//储存元素，匿名内部类形式
		al2.add( new Student("冯绍峰",20));
		al2.add( new Student("黄海波",24));
		//将集合元素添加到大集合中
		HashMap<String, ArrayList<Student>> hashMap = new HashMap<>();//泛型推断
		hashMap.put("巨星", al1);//al1的对象的类型
		hashMap.put("一线明星", al2);
		//老规矩：遍历先做非空判断
		Set<Entry<String, ArrayList<Student>>> es = hashMap.entrySet();//键值对对象
		if(es!=null){
			for(Entry<String, ArrayList<Student>> s:es){
				String key = s.getKey();//获取
				System.out.println(key);
				ArrayList<Student> value = s.getValue();//获取
				for(Student student:value){//遍历
					System.out.println("\t"+student.getName()+"\t"+student.getName());
				}
			}
		}
		
	}
	
}

 

3.2  HashMap嵌套HashMap

   以上述为例，仍打印上面的内容

 

练习2

 

package demo;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

/**
 * @author Orange
 * @version 1.8
 */
public class Demo4 {
	/**
	 * HashMap嵌套HashMap
	 */
	public static void main(String[] args) {
		//创建两个小集合---保存元素
		HashMap<String, Integer> hm1 = new HashMap<String,Integer>();
		hm1.put("林正英",18);
		hm1.put("李小龙",24);
		HashMap<String, Integer> hm2 = new HashMap<String,Integer>();
		hm2.put("冯绍峰",20);
		hm2.put("黄海波",24);
		//创建大集合
		HashMap<String, HashMap<String, Integer>> hashMap = new HashMap<>();
		hashMap.put("巨星", hm1);
		hashMap.put("一线明星", hm2);
		if(hashMap!=null){//其实没必要---hashMap键值都可以是null
			Set<String> keySet = hashMap.keySet();//得到键集合
			if(keySet!=null){                     //非空判断
				for(String s:keySet){         //遍历键集合
					System.out.println(s);
					//根据键获取值
					HashMap<String, Integer> hashMap2 = hashMap.get(s);
					    Set<Entry<String, Integer>> entrySet = hashMap2.entrySet();
					    //对里层的hashMap做遍历，其实还是得做非空判断
						for(Entry<String, Integer> s1:entrySet){
							System.out.println("\t"+s1.getKey()+"---"+s1.getValue());
					}
				}
			}
		}
	}
	
}

说明：Map的值对象还可以是Map类型，但是键对象不可以111

 

3.3 ArrayList之HashMap

 

打印如下内容：

     周瑜---小乔
     吕布---貂蝉

     郭靖---黄蓉
     杨过---小龙女

     令狐冲---任盈盈
     林平之---岳灵珊

练习3

 

package demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

/**
 * @author Orange
 * @version 1.8
 */
public class Demo05 {
	public static void main(String[] args) {
		HashMap<String, String> hashMap1 = new HashMap<String, String>();
		hashMap1.put("周瑜", "貂蝉");
		hashMap1.put("杨过", "杨玉环");
		HashMap<String, String> hashMap2 = new HashMap<String, String>();
		hashMap2.put("郭靖", "杨桃");
		hashMap2.put("吕布", "凤姐");
		HashMap<String, String> hashMap3 = new HashMap<String, String>();
		hashMap3.put("令狐冲", "高圆圆");
		hashMap3.put("林平之", "白晶晶");
		ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
		arrayList.add(hashMap1);
		arrayList.add(hashMap2);
		arrayList.add(hashMap3);
		if(arrayList!=null){//非空判断
			for(HashMap<String, String> hm:arrayList){//对ArrayList元素遍历
				Set<Entry<String, String>> eS = hm.entrySet();//有两个键值对对象
				for(Entry<String, String> se:eS){//得到每个键值对对象的键和值
					System.out.println(se.getKey()+"---"+se.getValue());
				}
				System.out.println();
			}
		}
	}
}

未完待续......