1. import java.util.LinkedList;
   
2. 
   
3. /*练习：使用LinkedList模拟一个堆栈，队列数据结构
   
4. *堆栈：先进后出
   
5. *队列：先进先出
   
6. */
   
7. class DuiLie{
   
8.         private LinkedList link;
   
9.         DuiLie(){
   
10.                 link = new LinkedList();
    
11.         }
    
12.         public void myAdd(Object obj){
    
13.                 link.addFirst(obj);
    
14.         }
    
15.         public Object myGet(){
    
16.                 return link.getLast();
    
17.         }
    
18.         public boolean isNull(){
    
19.                 return link.isEmpty();
    
20.         }
    
21. }
    
22. //javaweb中的session appication域都是这种封装方式

复制代码

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. 
   
4. //练习：除去ArrayList中的重复元素
   
5. class Test{
   
6.         public static ArrayList singleElement(ArrayList<E> al){
   
7.                 ArrayList newAl = new ArrayList();
   
8.                 Iterator it = al.iterator();
   
9.                 while(it.hasNext()){
   
10.                         Object obj = it.next();
    
11.                         if(!newAl.contains(obj))
    
12.                                 newAl.add(obj);
    
13.                 }
    
14.                 return newAl;
    
15.         }
    
16. }

复制代码

1. /*
   
2. * 练习：将自定义对象作为元素存储到ArrayList中，并去除重复元素
   
3. * Person同名同年龄视为同一个人，为重复元素
   
4. * List集合的contains方法判断元素是否相同，用的是元素的equals方法
   
5. * 由此，remove方法的寻找也用equals
   
6. */
   
7. class Person{
   
8.         private String name;
   
9.         private int age;
   
10.         public Person(String name, int age) {
    
11.                 super();
    
12.                 this.name = name;
    
13.                 this.age = age;
    
14.         }
    
15.         public String getName() {
    
16.                 return name;
    
17.         }
    
18.         public int getAge() {
    
19.                 return age;
    
20.         }
    
21.         public boolean equals(Object obj) {
    
22.                 if (!(obj instanceof Person))
    
23.                         return false;
    
24.                 Person p = (Person) obj;
    
25.                 return this.name.equals(p.name) && this.age==p.age;
    
26.         }
    
27. }
    
28. //注意，在没有泛型的情况下，迭代器获取的是Object，需要做强转

复制代码

1. public int hashCode(){
   
2.         return name.hashCode()+age*39;//防止出现40+20=20+40的情况，乘以一个任意数，尽量保证哈希值唯一。
   
3. }

复制代码

1. public int compareTo(Object o){
   
2.         return 1;
   
3. }

复制代码

1. //使用构造函数 TreeSet(Comparator comparator)
   
2. class Mycompare implements Comparator{
   
3.         public int compare(Object o1,Object o2){}
   
4. }

复制代码

1. /*
   
2. * 练习：向TreeSet中存入字符串，按字符串长度排序
   
3. * String本身具备比较性，但不符合要求，要使用比较器
   
4. */
   
5. class StringLengthComparator implements Comparator{
   
6.         public int compare(Object o1,Object o2){
   
7.                 String s1 = (String)o1;
   
8.                 String s2 = (String)o2;
   
9.                 if(s1.length()>s2.length())
   
10.                         return 1;
    
11.                 if(s1.length()==s2.length())
    
12.                         return s1.compareTo(s2);
    
13.                 return -1;
    
14.         }
    
15. }
    
16. /*
    
17. * 可改为
    
18. * int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
    
19. * if(num==0)
    
20. *   return s1.compareTo(s2);
    
21. * return num;
    
22. */
    
23. /*
    
24. * 可以使用匿名内部类
    
25. * TreeSet ts = new TreeSet(new Comparator{
    
26. *         public int compare(Object o1,Object o2){}
    
27. * })
    
28. */

复制代码

1. class Utils<T>{
   
2.         private T t;
   
3.         public void setObject(T t){
   
4.                 this.t = t;
   
5.         }
   
6.         public T getObject(){
   
7.                 return t;
   
8.         }
   
9. }

复制代码

1. class InterImpl implements Inter<String>{
   
2.         public void show(String str){
   
3.                 System.out.println("show"+s);
   
4.         }
   
5. }

复制代码

1. //继承泛型：此时创建对象时明确泛型
   
2. class InterImpl<T> implements Inter<T>{
   
3.         public void show(T t){
   
4.                 System.out.println("show"+t);
   
5.         }
   
6. }

复制代码

1. void chear()
   
2. boolean containsKey(Object key)
   
3. boolean containsValue(Object value)
   
4. V get(Object key)//获取返回null可用于判断键是否存在
   
5. boolean isEmpty()
   
6. V put(K key,V value)//当存相同键时，新值替换老值，返回老值，首次存入键返回null
   
7. void putAll(Map m)
   
8. V remove(Object key)
   
9. int size()
   
10. Collection values()
    
11. Set entrySet()
    
12. Set keySet()
    
13. String toString()//返回的是{key=value,key=value}

复制代码

1. Set<String> keySet = map.keySet();
   
2. Iterator<String> it = keySet.iterator();
   
3. while(it.hasNext()){
   
4.         String key = it.next();
   
5.         String value = map.get(key);
   
6.         System.out.println(key+"..."+value)
   
7. }
   
8. //keySet返回本集合所有键，存入Set中

复制代码

1. Set<Map.Entry<String,String>> entrySet = map.entrySet();
   
2. Iterator<Map.Entry<String,String>> it = entrySet.iterator();
   
3. while(it.hasNext()){
   
4.         Map.Entry<String,String> me = it.next();
   
5.         String key = me.getKey();
   
6.         String value = me.getValue();
   
7. }

复制代码

1. import java.util.Iterator;
   
2. import java.util.Map;
   
3. import java.util.Set;
   
4. import java.util.TreeMap;
   
5. 
   
6. //练习：获取字母出现次数
   
7. class Test{
   
8.         public static String charCount(String str){
   
9.                 char[] chs = str.toCharArray();
   
10.                 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
    
11.                 int count = 0;
    
12.                 for(int x=0;x<chs.length;x++){
    
13.                         if(!((chs[x]>='a' && chs[x]<='z') || (chs[x]>='A' && chs[x]<='Z')))
    
14.                                 continue;
    
15.                         Integer value = tm.get(chs[x]);
    
16.                         if(value!=null)
    
17.                                 count = value;
    
18.                         count++;
    
19.                         tm.put(chs[x], count);
    
20.                         count = 0;
    
21.                 }
    
22.                 StringBuilder sb = new StringBuilder();
    
23.                 Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
    
24.                 Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
    
25.                 while(it.hasNext()){
    
26.                         Map.Entry<Character, Integer> me = it.next();
    
27.                         Character ch = me.getKey();
    
28.                         Integer value = me.getValue();
    
29.                         sb.append(ch+"("+value+")");
    
30.                 }
    
31.                 return sb.toString();
    
32.         }
    
33. }

复制代码

1. static <T extends Comparable<? super T>> void sort(List<T> list)
   
2.   //当List元素具备比较性时，对List排序。也可以传比较器
   
3.   static <T> void sort(List<t> list,Comparator<? super T> )
   
4. static <T extends Object&Comparable<? super T>> T max(Collection<? extends T> coll)
   
5.   //根据自然排序，取集合的最大元素，也可以传比较器。min方法类似
   
6. static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
   
7.   //对集合进行二分查找。也可以使用比较器。注意使用比较器时，排序和二分查找要用同一个比较器。
   
8.   //二分查找的前提是集合有序。二分查找当找不到时，返回-插入点-1
   
9. static <T> void fill(List<? super T> list,T obj)
   
10.   //用指定元素obj替换集合中的所有元素
    
11. static boolean replaceAll(List<T> list,T oldVal,T newVal)
    
12.   //替换指定元素
    
13. static void reverse(List<?> list)
    
14.   //反转集合
    
15. static <T> comparator<T> reverseOrder()
    
16.   //返回一个自然排序的逆序比较器
    
17. static <T> comparator<T> reverseOrder(Comparator<T> cmp)
    
18.   //将一个比较器逆转返回
    
19. static Collection<T> synchronizedCollection(Collection<T> c)
    
20.   //一系列方法将传入的集合转成线程同步的并返回，其底层实现用同锁同步代码块，Collection，Map，List，Set都有该方法
    
21. static void swap(List<?> list,int i,int j)
    
22.   //交换元素位置
    
23. static void shuffle(List<?> list)
    
24.   //随机重置集合中元素位置

复制代码

1. static int binarySearch(int[] a,int key)
   
2.   //一系列方法，二分查找，也可以设置起始位置，结束位置。byte[],char[],double[],float[]
   
3.   //long[],Object[],short[],T[]都有该方法
   
4. static int[] copyOf(int[] arr,int newLength)
   
5.   //一系列方法，数组复制。各数据类型都有。copyOfRange(int[] arr,int from,int to)复制一个范围
   
6. static boolean equals(int[] a,int[] b)
   
7.   //一系列方法，比较数组。比较的是元素，要元素和顺序都一致。各类型都有。
   
8. static void fill(int[] a,nt val)
   
9.   //一系列方法，替换数组值，可指定范围，各类型都有
   
10. static void sort(int[] a)
    
11.   //一系列方法，排序，可指定范围，各类型都有
    
12. static String toString()
    
13.   //一系列方法，返回数组内容的字符串

复制代码

谢谢楼主分享，有的看过了有的学习了

1. static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
   
2.   //修改dest数组，从srcPos开始截取，截取length个，从destPos开始覆盖
   
3. static long currentTimeMillis()
   
4.   //返回当前时间毫秒值
   
5. static void exit(int status)
   
6.   //终止JVM  等效于 Runtime.getRuntime().exit(n)
   
7. static void gc()
   
8.   //执行垃圾回收器
   
9. static Properties getProperties()
   
10.   //System类会描述系统环境，记录系统启动时的加载信息。该方法获取系统属性信息。
    
11.   //获取的JVM,JDK以及当前操作系统的一些信息
    
12.   Properties：HashTable的子类，与IO相关。其作为一个集合，可以取也可以存。
    
13.   //注意该Properties取出时是<Object,Object>,存入时则是<String,String>
    
14.   //java的一个命令参数java -Dkey=value能在启动JVM时动态的为系统添加一些信息。

复制代码

1. static int abs(int a)//取绝对值，float long double都有
   
2. static double ceil(double a)//入，注意小数
   
3. static double floor(double a)//舍，注意小数
   
4. static int round(float a)//四舍五入 long-double也有
   
5. static double pow(double a,double b)//a的b次方
   
6. static double random()//返回一个0.0~1.0的随机小数，包含0不包含1
   
7.   java.util包中有一个Random类，可以直接new，其全部方法就是各种next。
   
8.     常用int r.nextInt(n)  0~n的随机数，不包含n

复制代码

lz加油~~~~