3,把集合中的元素反转
        a,定义循环, 循环size()/2次
        b,第一次交换第一个和最后一个, 第二次交换第二个和倒数第二个

4,public static void main(String[] args) {
                List<String> list1 = new ArrayList<>();
                list1.add("b");
                list1.add("f");
                list1.add("e");
                list1.add("c");
                list1.add("a");
                list1.add("d");
                sort1(list1);
                System.out.println(list1);        // a, b, c, d, e, f
               
                List<Integer> list2 = new ArrayList<>();
                list2.add(5);
                list2.add(8);
                list2.add(3);
                list2.add(1);
                list2.add(4);

                sort2(list2);
                System.out.println(list2); //1,3,4,5,8
        }
        对集合中添加的元素排序
5,List<String> list = new ArrayList<>();
               
                list.add("a");
                list.add("a");
                list.add("a");
                list.add("b");
                list.add("b");
                list.add("c");
                list.add("d");
                list.add("d");
                list.add("d");
                list.add("d");
                list.add("d");
               
                System.out.println(frequency(list, "a"));        // 3
                System.out.println(frequency(list, "b"));        // 2
                System.out.println(frequency(list, "c"));        // 1
                System.out.println(frequency(list, "d"));        // 5
                System.out.println(frequency(list, "xxx"));        // 0
                定义方法统计集合中指定元素出现的次数
6,定义一个replaceAll方法,将传入的新值替换集合中的老值(list,old,new)

主要是第四题

第四题啊 简单 加一句

1. private static <T extends Comparable<T>> void sort1(List<T> list1) {
   
2.                 Collections.sort(list1);
   
3.         }

复制代码

zsh3280 发表于 2016-3-22 12:00
第四题啊 简单 加一句

谢谢! 但是好像还没学Collections这个类.  如果不用collections的话 是不是要先转换成数组 然后用arrays排序 再转回集合啊?

collection里还有sort方法?视频里没讲过啊,API里也没有

[Java] 纯文本查看 复制代码

	public static void sort1(List<String> list) {
		
		//集合排序工具传入一个比较器
		for (int i = 0; i < list.size() - 1; i++) {
			int indexMax = i;
			for (int j = i + 1; j < list.size(); j++) {
				String s1 = list.get(i);
				String s2 = list.get(j);
				char c1 = s1.toCharArray()[0];
				char c2 = s2.toCharArray()[0];
				if (c1 > c2) {
					indexMax = j;
				}
			}
			//交换位置
			change(list, i , indexMax);
		}
	}
	public static void change(List<String> list, int i, int indexMax) {
		String temp = list.remove(indexMax);
		list.add(indexMax - 1, list.get(i));
		list.remove(i);
		list.add(i, temp);
	}

不用Collections类就这样吧!

这题用Collections.sort()简单快捷。如果以后要对一系列对象做特定要求的排序就要用比较器排序，放弃来回转化吧少年…………day16有毒么…你们扎堆问day16……

小伙子你暴露了啊

/*public static <E> void sort1(List<E> list) {
                E[] arr = (E[])list.toArray();
                list.clear();
                Arrays.sort(arr);
                for (E e : arr) {
                        list.add(e);
                }
        }*/
       
        public static void sort1(List<String> list) {
                String[] arr = list.toArray(new String[list.size()]);
                list.clear();
                for(int times = 0; times < arr.length - 1; times++ ) {
                        for(int index = 0; index <arr.length - 1 - times ; index++) {
                                if(arr[index].compareTo(arr[index + 1]) > 0) {
                                        String temp = arr[index];
                                        arr[index] = arr[index + 1];
                                        arr[index + 1] = temp;
                                }
                        }
                }
                for (String string : arr) {
                        list.add(string);
                }
        }
       
       
       
        /*public static <E> void sort2(List<E> list) {
                E[] arr = (E[])list.toArray();
                list.clear();
                Arrays.sort(arr);
                for (E e : arr) {
                        list.add(e);
                }
        }*/
       
        public static void sort2(List<Integer> list) {
                Integer[] arr = list.toArray(new Integer[list.size()]);
                list.clear();
                for(int times = 0; times < arr.length - 1; times++ ) {
                        for(int index = 0; index <arr.length - 1 - times ; index++) {
                                if(arr[index].compareTo(arr[index + 1]) > 0) {
                                        arr[index] = arr[index] ^ arr[index + 1];
                                        arr[index + 1] = arr[index] ^ arr[index + 1];
                                        arr[index] = arr[index] ^ arr[index + 1];
                                }
                        }
                }
                for (Integer i : arr) {
                        list.add(i);
                }
        }

第四题，其实就是之前你应该学过的冒泡排序和选择排序的运用，当然如果你学了Arrays类和泛型会更简单（注释中用的方法）