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;
}
}
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];
}
}
扫一扫
1687
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
