JavaSE_集合框架

最新推荐文章于 2024-04-23 19:41:13 发布
最新推荐文章于 2024-04-23 19:41:13 发布
阅读量984 收藏
点赞数
分类专栏： # JavaSE 文章标签： javase 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pre_eminent/article/details/17717819
版权

ComparatorByStringLength

package Collection;
import java.util.Comparator;
import java.util.TreeSet;
//CollectionsDemo.java中new TreeSet的构造函数用到! 
//策略设计模式~自己不知道如何处理,暴露接口,让调用者自己处理
public class ComparatorByStringLength implements Comparator<String> {

public int compare(String o1, String o2) {
int temp=o1.length()-o2.length();
//如果长度相等的时候,才按照字符串自己的比较方法~
return temp==0?o1.compareTo(o2):temp;
}

}
CollectionsDemo_工具类 
package Collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
public class CollectionsDemo {
   //集合工具Collections的方法:随机shuffle陈列
   @Test
   public void method14() {
//      static void shuffle(List<?> list) 
//        使用默认随机源对指定列表进行置换。 
      List<String> ls=new ArrayList<String>();
      ls.add("abc");
      ls.add("nba");
      ls.add("sg");
      ls.add("keke");
      ls.add("lily");
      System.out.println(ls);
      //[abc, nba, sg, keke, lily]
      Collections.shuffle(ls);
      System.out.println(ls);
       //[nba, keke, sg, abc, lily]
   }
   @Test
   public void method13() {
//      static <T> void 
//       fill(List<? super T> list, T obj) 
//                使用指定元素替换指定列表中的所有元素。 
      List<String> ls=new ArrayList<String>(12);
      ls.add("林黛玉");
      ls.add("薛宝钗");
      ls.add("贾元春");
      ls.add("贾探春");
      ls.add("史湘云");
      ls.add("妙玉");
      ls.add("贾迎春");
      ls.add("贾惜春");
      ls.add("王熙凤");
      ls.add("贾巧姐");
      ls.add("李纨");
      ls.add("秦可卿");
      System.out.println(ls);
      //[林黛玉, 薛宝钗, 贾元春, 贾探春, 史湘云, 妙玉, 贾迎春, 贾惜春, 王熙凤, 贾巧姐, 李纨, 秦可卿]
      Collections.fill(ls, "悲剧");
      System.out.println(ls);
       //[悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧, 悲剧]
   }
   @Test
   public void method12() {
//      static <T> boolean 
//       replaceAll(List<T> list, T oldVal, T newVal) 
//                使用另一个值替换列表中出现的所有某一指定值。 
      List<String> ls=new ArrayList<String>();
      ls.add("abc");
      ls.add("nba");
      ls.add("sg");
      ls.add("lily");
      System.out.println(ls);
      //[abc, nba, sg, lily]
      Collections.replaceAll(ls, "abc", "cba");
      //思路:set(indexOf("oldValue"),"newValue")
      System.out.println(ls);
       //[cba, nba, sg, lily]
   }
   @Test
   public void method11() {
//      static void reverse(List<?> list) 
//        反转指定列表中元素的顺序。 
      List<String> ls=new ArrayList<String>();
      ls.add("贾元春");
      ls.add("贾迎春");
      ls.add("贾探春");
      ls.add("贾惜春");
      System.out.println(ls);
//      [贾元春, 贾迎春, 贾探春, 贾惜春]
      Collections.reverse(ls);
      System.out.println(ls);
//       [贾惜春, 贾探春, 贾迎春, 贾元春]
   }
   @Test
   public void method10() {
      //逆序 和替换---TreeSet顺序打印,按长度排序!从大到小
//      static <T> Comparator<T> 
//       reverseOrder(Comparator<T> cmp) 
//                返回一个比较器，它强行逆转指定比较器的顺序。 
      //TreeSet<String> ts=new TreeSet<String>(new ComparatorByStringLength());
      //本来按长度排序是这样~[sg, abc, nba, lily]
      TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new ComparatorByStringLength()));
      ts.add("abc");
      ts.add("nba");
      ts.add("sg");
      ts.add("lily");
      System.out.println(ts);
      //现在被逆转后,却是这样~[lily, nba, abc, sg]
   }
   @Test
   public void method9() {
      // 逆序 和替换---TreeSet顺序打印,按长度排序!从小到大
            TreeSet<String> ts=new TreeSet<String>(new ComparatorByStringLength());
            ts.add("abc");
            ts.add("nba");
            ts.add("sg");
            ts.add("lily");
            System.out.println(ts);//[sg, abc, nba, lily]
   }
   @Test
   public void method8() {
//      static <T> Comparator<T> 
//       reverseOrder() 
//                返回一个比较器，它强行逆转实现了 Comparable 
//      接口的对象 collection 的自然顺序。 
//      Collections.reverseOrder()返回一个比较器,Comparator
            TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());
            ts.add("abc");
            ts.add("nba");
            ts.add("sg");
            ts.add("lily");
            System.out.println(ts);
            //本来字符串的自然排序是按字母顺序,逆转后却是:[sg, nba, lily, abc]

   }
   @Test
   public void method7() {
      // 逆序 和替换---TreeSet顺序打印,匿名内部类,实现抽象方法
      TreeSet<String> ts=new TreeSet<String>(new Comparator<String>(){
         public int compare(String o1, String o2) {
            //int temp=o1.compareTo(o2);结果是正序[abc, lily, nba, sg]
            int temp=o2.compareTo(o1);//结果是逆序[sg, nba, lily, abc]
            return temp;
         }
      });
      ts.add("abc");
      ts.add("nba");
      ts.add("sg");
      ts.add("lily");
      System.out.println(ts);//[sg, nba, lily, abc]
   }
   @Test
   public void method6() {
      // TreeSet顺序打印
      TreeSet<String> ts=new TreeSet<String>();
      ts.add("abc");
      ts.add("nba");
      ts.add("sg");
      ts.add("lily");
      System.out.println(ts);
      //正常字母顺序排序:[abc, lily, nba, sg]
   }
   @Test
   public void method5() {
      // max,分别按自然排序和字符串长度
      List<String> li=new ArrayList<String>();
      li.add("ab");
      li.add("dab");
      li.add("pre_eminent");
      li.add("kab");
      li.add("zombie");
      System.out.println(Collections.max(li));//取出按自然排序的max  zombie
      System.out.println(Collections.max(li, new ComparatorByStringLength()));
      //取出集合 按长度排序后的最长的元素 pre_eminent
   }
   @Test
   public void method4() {
      // binarySearch二分法查找
      List<String> li=new ArrayList<String>();
      li.add("ab");
      li.add("cd");
      li.add("ijk");
      li.add("opq");
      li.add("xyz");
      Collections.sort(li);
      System.out.println(li);
      //[ab, cd, ijk, opq, xyz]
      int result=Collections.binarySearch(li, "zabc");
      System.out.println(result);//插入的位置的负数减1; -6
      result=Collections.binarySearch(li, "ijk");
      System.out.println(result);//返回元素在数组的下标位置2  从0开始算
   }
   @Test
   public void method3() {
      // 使用Comparator排序!按长度进行排列
      List<String> li=new ArrayList<String>();
      li.add("ab");
      li.add("ijk");
      li.add("pre_eminent");
      li.add("xyz");
      li.add("chongfu");
      System.out.println(li);
      //[ab, ijk, pre_eminent, xyz, chongfu]
      MySort3(li,new ComparatorByStringLength());//使用MySort进行集合的排序!
      //Collections.sort(li,new ComparatorByStringLength());//使用工具类Collections进行集合的排序!
      System.out.println(li);
      //[ab, ijk, xyz, chongfu, pre_eminent]
   }
   //重点!自定义实现工具类的sort方法! 注意泛型~
   public <T> void MySort3(List<T> li,Comparator<? super T> comp) {
      //选择排序~
      for (int i = 0; i <li.size()-1; i++) {
         for (int j = i+1; j <li.size(); j++) {
            //调用用户传入的比较器的compare方法,进行比较~
            if(comp.compare(li.get(i),li.get(j))>0){//对象比较用compareTo
               Collections.swap(li, i, j);//使用提供的swap
            }
         }
      }
   }
   @Test
   public void method2() {
      //使用MySort进行集合的排序!
      List<String> li=new ArrayList<String>();
      li.add("ab");
      li.add("dab");
      li.add("chongfu");
      li.add("kab");
      li.add("chongfu");
      System.out.println(li);
      MySort2(li);//使用MySort进行集合的排序!
      System.out.println(li);
   }
   
   public <T extends Comparable <? super T>> void MySort2(List<T> li) {
      // 选择排序算法!带泛型!!!参数(集合)的成员必须是可比较的~
      for (int i = 0; i <li.size()-1; i++) {
         for (int j = i+1; j <li.size(); j++) {
            if(li.get(i).compareTo(li.get(j))>0){//对象比较用compareTo
               //swap
               /*    T temp=li.get(i);
               li.set(i,li.get(j));
               li.set(j,temp);               */
               Collections.swap(li, i, j);//使用提供的swap
            }
         }
      }
   }
   public  void MySort(List<String> li) {
      // 选择排序算法!
      for (int i = 0; i <li.size()-1; i++) {
         for (int j = i+1; j <li.size(); j++) {
            if(li.get(i).compareTo(li.get(j))>0){//对象比较用compareTo
               //swap
               String temp=li.get(i);
               li.set(i,li.get(j));
               li.set(j,temp);
            }
         }
      }
   }
   @Test
   public void method1() {
      // 工具类, 对集合进行排序,可以有重复
      List<String> li=new ArrayList<String>();
      li.add("ab");
      li.add("dab");
      li.add("chongfu");
      li.add("kab");
      li.add("chongfu");
      System.out.println(li);
      Collections.sort(li);
      System.out.println(li);
      /*[ab, dab, chongfu, kab, chongfu]
         [ab, chongfu, chongfu, dab, kab]*/
   }
}


LinkedHashMapDemo

package Collection;


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


import org.junit.Test;


public class LinkedHashMapDemo {
	@Test
	public void method1() {
		// new HashMap(),存入数字作为key的时候会按哈希算法排序!!!
		//如果是new LinkedHashMap(),那就怎么进去,怎么出来!!!购物车时用,存取有序
		HashMap<Integer, String> hs = new HashMap<Integer, String>();
		hs.put(1, "林黛玉");
		hs.put(2, "薛宝钗");
		hs.put(3, "贾元春");
		hs.put(4, "贾探春");
		hs.put(5, "史湘云");
		hs.put(6, "妙玉");
		hs.put(7, "贾迎春");
		hs.put(8, "贾惜春");
		hs.put(9, "王熙凤");
		hs.put(10, "贾巧姐");
		hs.put(11, "李纨");
		hs.put(12, "秦可卿");
		Set<Entry<Integer, String>> set = hs.entrySet();
		Iterator<Entry<Integer, String>> it = set.iterator();
		//Iterator<Map.Entry<Integer, String>> it=hs.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry<Integer, String> entry = it.next();
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + "..." + value);
		}
	}
}


TreeMapTest1

package Collection;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class TreeMapTest1 {
	public static void main(String[] args) {
		// 统计字符串中各个字母(或字符)出现的个数,牛X的思路~
		String s1 = "abcdeabca";
		method1(s1);
	}

	private static void method2(String s1) {
		// 改进版本
		// 第1步,定义字符数组,然后是TreeMap<Character,Integer>
		char[] chs = s1.toCharArray();
		Map<Character, Integer> map = new TreeMap<Character, Integer>();
		for (int i = 0; i < chs.length; i++) {
			// 循环里面首先在中根据键取值,再分情况对值进行判断
			// V get(Object key) 返回指定键所映射的值；
			// 如果此映射不包含该键的映射关系，则返回 null。
			// 改进之处:每次初始化count值为1;
			int count = 1;
			Integer value = map.get(chs[i]);// 返回指定键(字符)所映射的值(次数count)；
			if (value != null) {
				count = value + 1;
			}
			map.put(chs[i], count);// 再将该键(字符)的次数(count)存回map
		}
		// 上面的循环是统计并存入Map,下面直接打印map.toString()
		// System.out.println(map.toString());
		printMap(map);// 调用自定义打印方法
	}

	public static void printMap(Map<Character, Integer> map) {
		// 自定义打印Map方法,注意迭代器泛型和集合要一致!
		StringBuilder sb = new StringBuilder();
		Iterator<Character> it = map.keySet().iterator();
		while (it.hasNext()) {
			Character key = it.next();
			// 如果只打印字母加上这一句
			if (!(key >= 'a' && key <= 'z' || key >= 'A' && key <= 'Z')) {
				continue;
			}
			Integer value = map.get(key);
			sb.append(key + "(" + value + ")");
		}
		System.out.println(sb);
	}

	public static void method1(String s1) {
		// 第1步,定义字符数组,然后是TreeMap<Character,Integer>
		char[] chs = s1.toCharArray();
		Map<Character, Integer> map = new TreeMap<Character, Integer>();
		for (int i = 0; i < chs.length; i++) {
			// 循环里面首先在中根据键取值,再分情况对值进行判断
			// V get(Object key) 返回指定键所映射的值；
			// 如果此映射不包含该键的映射关系，则返回 null。
			Integer value = map.get(chs[i]);
			if (value == null) {
				map.put(chs[i], 1);
			} else {
				map.put(chs[i], value + 1);
			}
		}
		//上面的循环是统计并存入Map,下面直接打印map.toString()
		System.out.println(map.toString());
	}
}


TreeMapTest2

package Collection;

import java.util.HashMap;
import java.util.Map;

public class TreeMapTest2 {
	public static void main(String[] args) {
		String week = method2(41);
		System.out.println(week);
	}

	private static String method2(int i) {
		// 新办法,用HashMap<Integer,String>
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Mon");
		map.put(2, "Tue");
		map.put(3, "Wed");
		map.put(4, "Thu");
		map.put(5, "Fri");
		map.put(6, "Sat");
		map.put(7, "Sun");
		return map.get(i);
	}

	private static String method1(int i) {
		// 老办法用数组取星期
		// 用查表法根据数字查星期几!
		// 增强健壮性检查
		if (i > 7 || i < 0) {
			return "wrong number";
			// throw new RuntimeException("对不起,请重新输入!");
		}
		String[] arr = { "", "星期1", "星期2", "星期3", "星期4", "星期5", "星期6", "星期天" };
		return arr[i];
	}
}











pre_eminent
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中pre是什么意思,【java】Spring Security源码中 的@PreAuthorize注解究竟在哪一个拦截器里进行判断的...
weixin_33417703的博客
03-21 1647
@PermitAll@PreAuthorize(“isAnonymous()”)@PreAuthorize(“permitAll”)各种写法都试过了，都是无效。根本无法直接请求这些免鉴权的接口。能百度出来的写法都写全了。依然无效。@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabl...
JavaSE_JavaSE学习资料_
10-02
这个编程资料包涵盖了JavaSE的学习资源，旨在帮助开发者掌握Java的基础知识、集合框架、IO流等关键概念。 首先，Java基础知识是学习JavaSE的起点。这包括了Java语法、数据类型、控制结构（如if语句、for循环、while...
java中pre是什么意思_HTML标签<PRE>在代码中是什么意思
weixin_32309649的博客
02-25 2125
展开全部1.容器是用来存储和组织其他e68a843231313335323631343130323136353331333366306462对象的对象。实现链表的类就是一个容器的示例。预格式化文本容器存储实现构造自己的特定类型下的数据结构对象，这些模板的参数允许我们指定容器中元素的数据类型，可以将许多重复而乏味的工作简化。2.pre 元素可定义预格式化的文本。被包围在 pre 元素中的文本通常会保...
JavaSE_ 集合框架 总目录(15~18)
diaoji9561的博客
06-03 153
JavaSE学习总结第15天_集合框架1 15.01 对象数组的概述和使用15.02 对象数组的内存图解15.03 集合的由来及与数组的区别15.04 集合的继承体系图解15.05 Collection集合的功能概述15.06 Collection集合的基本功能测试15.07 Collection集合的高级功能测试15.08 集合的遍历之集合转数组遍历15.09 Collection存储...
JavaSE(集合框架)
最新发布
qq_45559559的博客
04-23 844
Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces 和其实现类 classes。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储、检索 、管理。Collection：是一个接口，包含了大部分容器常用的一些方法。
JavaSE_15_集合框架（一）
weixin_42788897的博客
06-14 90
重点集合框架体系及常用接口；List集合主要实现类及区别；集合遍历方式；Set集合主要实现类及区别；Set去重原理及实现手段。难点集合遍历方式；Set去重原理及实现手段。
JavaSE_16_集合框架（二）
weixin_42788897的博客
06-14 39
重点Map集合的特点及使用；栈与队列的概念及使用。难点Map集合结构及遍历方式。
JavaSE_集合
2301_78085386的博客
04-18 509
当我们需要保存一组一样（类型相同）的元素的时候，我们应该使用一个容器 来存储，数组就是这样一个容器。
javaSE-集合框架
peiwen_java的博客
04-01 133
一、ArrList的使用 1、ArrListDemo 二、Collection的使用 1、CollectionDemo java集合框架： * Collection：存放的是单一值 * 特点： * 1、可以存放不同类型的数据，而数组只能存放固定类型的数据 * 2、当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作 * api方法： * 增加数据的方...
Core Java SE.zip_JavaSE_API_java文档
09-20
它提供了丰富的API，包括集合框架、I/O流、多线程、网络编程、数据库连接（JDBC）、XML处理、GUI组件等，覆盖了软件开发的各个方面。 API（Application Programming Interface）文档是程序员在使用特定库或框架时的...
JavaSE_java基础_
10-01
6. **集合框架**：Java集合框架提供了一组接口和类，如List（ArrayList、LinkedList）、Set（HashSet、TreeSet）和Map（HashMap、TreeMap），它们是处理对象集合的常用工具。 7. **IO流**：Java的IO流处理包括输入...
02-Java语言进阶_javase_
10-01
2. **常用API**：Java API包含了大量预定义的类和接口，如集合框架、IO流、网络编程、多线程等。掌握这些API是提升开发效率的关键。 3. **缓冲流、转换流、序列化流**： - **缓冲流**：BufferedInputStream和...
javaSE_java_core.docx
02-28
Java中的集合框架包括`List`、`Set`和`Map`接口。`List`接口允许元素重复且保持插入顺序，常见的实现有`ArrayList`（基于数组）和`LinkedList`（基于链表）。`Set`接口不允许元素重复且无特定顺序，`HashSet`是常用...
javaSE之集合框架
放开那畜生的博客
05-18 255
集合框架   集合是一种长度可变的存储对象的容器，数组也是存储对象的容器，但是数组长度是固定的;   Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是List和Set。List是有序的集合，可以包含重复的元素，提供按索引访问的方式，Set不能包含重复的元素，且无序；   Map是Java.util包中的另一个接口，它和Co...
JavaSE_正则表达式
pre_eminent的JAVA学习园地
11-04 1247
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.MalformedURLException; import java.net.URL; import java.util.Tre
JavaSE_数组_2维数组+数组转集合
pre_eminent的JAVA学习园地
12-31 1059
二维数组定义 import org.junit.Test; public class Array_2 { @Test public void method4() { //二维数组的遍历 int[][] arr={{0,1,2},{3,4,5,6},{7,8,9}}; for (int i = 0; i < arr.length; i++) { for (int j = 0;
java模板代码
pre_eminent的JAVA学习园地
12-19 1058
Window----Preferences----temp----java----Templates       //SQL查询模板代码(sql_s)[sql_select_template]       Connection conn = null;       PreparedStatement st = null;       ResultSet rs = null;      
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值