java 一个键对应多个值怎么表示 java建立两个键值一个value |
您所在的位置：网站首页 › json一个键对应多个值怎么表示 › java 一个键对应多个值怎么表示 java建立两个键值一个value |
java 一个键对应多个值怎么表示 java建立两个键值一个value
|
关键词：Collection接口、Map接口、Iterator接口、泛型、Collections工具类、Arrays工具类
一、集合概述
当数据多了需要存储，需要容器，而数据的个数不确定，无法使用数组，这时可以使用Java中另一个容器——集合，位于java.util 。
1、集合和数组的区别？
① 数组的长度是固定的。
集合的长度是可变的。
②数组中存储的是同一类型的元素，可以存储基本数据类型值。
集合存储的都是对象。而且对象的类型可以不一致。
2、什么时候使用集合呢？
当对象多的时候，先进行存储。
3、集合体系框架图
二、Collection接口 Collection接口：单列集合类的根接口
1、List接口：有序的，带索引的，通过索引就可以精确的操作集合中的元素，允许出现重复的元素。 使用List解决插入元素的问题，因为add方法追加。 List接口的特有方法，全部是围绕索引来定义的。 List获取元素的方式有两种：一种是迭代，一种是遍历+get方法。 List接口是支持对元素进行curd增删改查动作的。
①Vector:可以增长的数组结构。同步的。效率非常低，已被ArrayList替代。 ②ArrayList:是数组结构，长度是可变的（原理创建新数组+复制数组）， 查询速度很快，增删较慢，不同步的。（应用广）。 示例： 1 public class Example01 { 2 public static void main(String[] args) { 3 ArrayList list = new ArrayList(); //创建ArrayList集合 4 list.add("stu1"); 5 list.add("stu2"); 6 list.add("stu3"); 7 list.add("stu4"); 8 System.out.println("集合的长度："+list.size());//获得集合中元素的个数 9 System.out.println("集合的第二个元素："+list.get(1));//取出并打印指定位置的元素 10 } 11 }
运行结果：
集合的长度：4集合的第二个元素：stu2
③LinktedList:是链接结构， 增删速度快，查询速度慢。可用于实现堆栈，队列。特有：围绕头和为展开定义的。
堆栈：先进后出First in Last Out FILO 可以理解为手枪弹夹
队列：先进先出First in First Out FILO 可以理解为排队买票
常用方法示例： 1 public class Example02 { 2 public static void main(String[] args) { 3 LinkedList link = new LinkedList();//创建LinkedList集合 4 link.add("stu1"); 5 link.add("stu2"); 6 link.add("stu3"); 7 link.add("stu4"); 8 System.out.println(link.toString());//取出元素并打印该集合中的元素 9 link.add(3,"Student"); //向该集合中的指定位置插入元素 10 link.addFirst("First"); //向该集合第一个位置插入元素 11 link.addLast("Last"); //向该集合第一个位置插入元素 12 System.out.println(link); 13 System.out.println(link.getFirst()); //取出该集合第一个元素 14 System.out.println(link.getLast()); //取出该集合最后一个个元素 15 link.remove(3); //移除该集合中指定位置的元素 16 link.removeFirst(); //移除该集合中第一个元素 17 link.removeLast(); //移除该集合中最后一个个元素 18 System.out.println(link); 19 } 20 }
运行结果： [stu1, stu2, stu3, stu4][First, stu1, stu2, stu3, Student, stu4, Last]FirstLast [stu1, stu2, Student, stu4]
2、Iterator接口 集合的取出方式：
①创建集合对象
Collection coll = new ArrayList();
②获取容器的迭代器对象，通过iterator方法；
Iterator it = coll.iterator();
③使用具体的迭代器对象获取集合中的元素； while (it.hasNext()){ System.out.println(it.next());}
实际开发建议使用以下方法(随着迭代完成，迭代器随之变成垃圾被清除，可以减少所占内存)： for（Iterator it = coll.iterator();it.hasNext();）{ System.out.println(it.next());}
该迭代器无法再迭代的过程中修改数组元素，否则会发生并发修改异常（ConcurrentModificationException）。 3、foreach: 其实就是增强for循环，用于遍历Collection和数组通常只能遍历元素，不要在遍历的过程中做对集合元素的操作。
格式：
for（元素数据类型 变量 ：collection集合or数组（））{执行语句}
和老式for循环的区别？
注意：新for循环必须有被遍历的目标。目标只能是Collection或者是数组。
建议：遍历数组时，如果仅为遍历，可以使用增强for，如果要对数组的元素进行操作，使用老式for循环可以通过角标操作。
示例： 1 public class Foreach { 2 static String [] strs = {"aaa","bbb","ccc"}; 3 public static void main(String[] args) { 4 //foreach循环遍历数组 5 for(Object obj : strs){ 6 System.out.println(obj); 7 } 8 System.out.println("______________"); 9 //foreach循环遍历数组并修改（修改失败） 10 for (String str : strs){ 11 str="ddd"; 12 } 13 System.out.println("foreach循环修改后的数组："+strs[0]+","+strs[1]+","+strs[2]); 14 //for循环遍历数组 15 for(int i = 0;i0){ //定义比较方法 14 return 1; 15 } 16 if (this.age-s.age==0){ 17 return this.name.compareTo(s.name);//将比较结果返回 18 } 19 return -1; 20 } 21 } 22 public class TreeSetDemo { 23 public static void main(String[] args) { 24 TreeSet ts = new TreeSet(); 25 ts.add(new Student("Jack",19)); 26 ts.add(new Student("Rose",18)); 27 ts.add(new Student("Tom",19)); 28 ts.add(new Student("Rose",18)); 29 Iterator it = ts.iterator(); 30 while (it.hasNext()){ 31 System.out.println(it.next()); 32 } 33 } 34 } 运行结果： Rose:18 Jack:19 Tom:19
到此为止：在往集合中存储对象时，通常该对象都需要覆盖hashCode，equals，同时实现Comparable接口，建立对象的自然排序。通常还有一个方法也会复写toString();
三、Map接口：
双列集合Map集合的特点： 内部存储的都是键key值value对，必须要保证键的唯一性。
Map集合常用方法
①Hashtable---数据结构：哈希表。是同步的，不允许null作为键和值。被HashMap替代。
子类Properties：属性表，键和值都是字符串，而且可以结合流进行键值操作。唯一一个可以和IO流结合使用的集合类。
②HashMap---数据结构：哈希表。不是同步的，允许null作为键和值。
示例： 1 public class Example15 { 2 public static void main(String[] args){ 3 Map map = new HashMap(); //创建Map对象 4 map.put("1","Jack"); //存储键和值，键相同，值覆盖 5 map.put("2","Rose"); 6 map.put("3","Lucy"); 7 map.put("3","Mary"); 8 System.out.println("1:"+map.get("1"));//根据键获取值 9 System.out.println("2:"+map.get("2")); 10 System.out.println("3:"+map.get("3")); 11 } 12 }
Map集合的两种遍历方式： 1 public class Example16 { 2 public static void main(String[] args){ 3 //第一种先遍历Map集合中所有的键，再跟据键获取相应的值。 4 Map map1 = new HashMap(); //创建Map对象 5 map1.put("1","Jack"); //存储键和值 6 map1.put("2","Rose"); 7 map1.put("3","Lucy"); 8 Set keySet1 = map1.keySet(); //获取键的集合 9 Iterator it1 = keySet1.iterator(); 10 while (keySet1.iterator().hasNext()){ // 迭代键的集合 11 Object key = it1.next(); 12 Object value = map1.get(key); //获得每个键所对应的值 13 System.out.println(key+":"+value); 14 } 15 16 //第二种先获取集合中的所有映射关系，然后从映射关系中取出键和值 17 Map map2 = new HashMap(); 18 map2.put("1","Jack"); //存储键和值 19 map2.put("2","Rose"); 20 map2.put("3","Lucy"); 21 Set entrySet = map2.entrySet(); 22 Iterator it = entrySet.iterator(); //获取Iterator对象 23 while (it.hasNext()){ 24 Map.Entry entry = (Map.Entry)(it.next()); //获取集合中键值对映射关系 25 Object key = entry.getKey(); //获取Entry中的键 26 Object value = entry.getValue(); //获取Entry中的值 27 System.out.println(key+":"+value); 28 } 29 } 30 }
运行结果：
1:Jack2:Rose3:Lucy
LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。
③TreeMap---数据结构：二叉树，保证键的唯一性，同步的，可以对map集合中的键进行排序。 1 //按学号从大排到小 2 public class Example20 { 3 public static void main(String[] args) { 4 TreeMap tm = new TreeMap(new MyCompartor()); //传入一个自定义比较器 5 tm.put("1","Jack"); //存储键和值 6 tm.put("2","Rose"); 7 tm.put("3","Lucy"); 8 Set keySet = tm.keySet(); //获取键的集合 9 Iterator it = keySet.iterator(); // 迭代键的集合 10 while (it.hasNext()){ 11 Object key = it.next(); 12 Object value = tm.get(key); //获得每个键所对应的值 13 System.out.println(key+":"+value); 14 } 15 } 16 } 17 class MyCompartor implements Comparator{ //自定义比较器 18 public int compare(Object o1, Object o2) { //实现比较方法 19 String id1 = (String) o1; //将Object类型的参数强转为String类型 20 String id2 = (String) o2; 21 return id2.compareTo(id1); //将比较结果之后的值返回，按字典相反顺序进行排序 22 } 23 }
运行结果： 3:Lucy2:Rose1:Jack
四、 泛型（parameterized type）
1、泛型的使用
体现，也是括号，往括号里写都写其实就是在传递参数。
格式：ArrayList list = new ArrayList();
泛型的优点：安全机制；将运行时期的ClassCastExecption转移到了编译时期变成了编译失败。泛型技术，是给编译器使用的技术。避免了强转的麻烦。 1 public class Example23 { 2 public static void main(String[] args) { 3 ArrayList list = new ArrayList(); 4 list.add("String"); 5 list.add("Collection"); 6 for(String str:list){ 7 System.out.println(str); 8 } 9 } 10 }
2、自定义泛型：
需求：请自己提供一个容器类。
分析：你要做一个容器类，你就应该知道容器类具备什么基本功能？
添加功能 save（）
获取功能 get（）
要做这样的方法，save是不是应该有参数呢？肯定的。
get（）应该有参数吗？这里我们可以不给形式参数，但是一定要有返回值类型。
基本格式：
void save （参数类型 参数）{…}
返回值类型 get（）{…..}
为了让我们的容器类能够存储任意类型的对象，我就应该给save（）方法中的参数定义为object类型。
当然，get（）方法的返回值类型应该是object类型。
出现问题：A 不兼容类型 B 类型转换异常
需求：自己定义一个泛型类并使用
如何定义一个泛型类呢？
就是把泛型安装其格式加在类上。
格式：
可以是E、T这样有意义的单词。
使用泛型后，我们可以不用再做类型转换了。 //在创建类时，声明参数类型为Tclass 类名{ T temp;//在创建save（）方法时，指定参数类型为T public void save (T temp){this.temp = temp} //在创建get()方法时，指定返回值类型为T public T get(){ return temp； } }
示例： 1 class CachePool{ 2 T temp; 3 public void save(T temp){ 4 this.temp=temp; 5 } 6 public T get() { 7 return temp; 8 } 9 } 10 public class Example26 { 11 public static void main(String[] args) { 12 CachePool pool = new CachePool(); 13 pool.save(new Integer(1)); 14 Integer temp = pool.get(); 15 System.out.println(temp); 16 } 17 }
五、Collections工具类
Collections：集合框架中的用于操作集合对象工具类。都是静态方法。 获取Collection最值。对List集合排序，也可以用二分查找。对排序逆序。可以将非同步的集合转变成同步的集合。如：Xxx synchronizedXxx(Xxx) -------List synchronizedList (List)//排序操作 1 public class Example27 { 2 public static void main(String[] args) { 3 ArrayList list = new ArrayList(); 4 Collections.addAll(list,"c","z","B","K"); 5 System.out.println("排序前："+list); 6 Collections.reverse(list); 7 System.out.println("反转后："+list); 8 Collections.shuffle(list); 9 System.out.println("按自然顺序排序后："+list); 10 Collections.sort(list); 11 System.out.println("洗牌后："+list); 12 } 13 }
运行结果：
排序前：[c, z, B, K]反转后：[K, B, z, c]按自然顺序排序后：[c, B, K, z]洗牌后：[B, K, c, z]
//查找、替换操作 1 public class Example28 { 2 public static void main(String[] args) { 3 ArrayList list = new ArrayList(); 4 Collections.addAll(list,-3,2,9,5,8); 5 System.out.println("集合中的元素："+list); 6 System.out.println("集合中的最大元素："+Collections.max(list)); 7 System.out.println("集合中的最小元素："+Collections.min(list)); 8 Collections.replaceAll(list,8,0); //将集合中的8用0替换掉 9 System.out.println("替换后的集合："+list); 10 } 11 }
运行结果： 集合中的元素：[-3, 2, 9, 5, 8]集合中的最大元素：9集合中的最小元素：-3替换后的集合：[-3, 2, 9, 5, 0]
六、Arrays：用于操作数组的工具类。类中定义的都是静态工具方法。 对数组排序。二分查找。数组复制。对两个数组进行元素的比较，判断两个数组是否相同。将数组转成字符串。1 //使用Arrays的sort()方法排序 2 public class Example29 { 3 public static void main(String[] args) { 4 int[] arr={9,8,3,5,2}; 5 System.out.print("排序前："); 6 printArray(arr); 7 Arrays.sort(arr); 8 System.out.print("排序后："); 9 printArray(arr); 10 } 11 public static void printArray(int[] arr) { 12 System.out.print("["); 13 for (int x=0;x |
【本文地址】