Java学习笔记七 常用API对象三

一、泛型:简单说就是对对象类型进行限定的技术

public class GenericDemo {
    public static void main(String[] args){
        /*泛型作为1.5版之后的新技术,分两步使用
         * 1、在类名之后用<类型参数>,这里就像函数中的普通参数一样命名即可
         * 2、在生成对象和返回该对象参数时需要明确具体的类型,相当于传入实参
         * 上面说的是泛型类,除此之外,泛型还可以用于类中方法和接口
         */
        GenericTest<Person> gt=new GenericTest<Person>();
        gt.setQ(new Person(21,"asd1"));

    }
}
//泛型类
class GenericTest<Q>{
    private Q q;

    public Q getQ() {
        return q;
    }

    public void setQ(Q q) {
        this.q = q;
    }
    //静态方法不能访问类中定义的泛型,如果必须使用泛型,只能将泛型定义在方法体上
    public static <W> void show1(W w){

    }
}
//泛型接口
interface Inter<T>{
    public void show(T t);
}
class InterImpl implements Inter<String>{
    public void show(String str){
        System.out.println("str="+str);
    }
}

泛型示例

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class GenericDemo2 {
    public static void main(String[] args){
        demo();
    }

    public static void demo() {
        ArrayList<String> al=new ArrayList<String>();
        al.add("asd1");
        al.add("asd2");
        //注意
        HashSet<Integer> hs=new HashSet<Integer>();
        hs.add(1);
        hs.add(2);
        printCollection(al);
        printCollection(hs);
    }

    /*这种参数和以前的类似,就是将类型提升到Collection,
     * 以便接受所有集合类型,然后用泛型规定集合中的元素类型
     * ?是通配符,在类型不确定时可以指代任意类型
     */
    private static void printCollection(Collection<?> coll) {
        for (Iterator<?> i = coll.iterator(); i.hasNext();) {
            System.out.println(i.next());
        }
    }

//下面这种方式使用泛型方法,和上面使用?通配符类似,
//只是T可以指代具体,而?不行。如果需要对类型进行操作,就需要使用这种方式
//    private static <T> void printCollection(Collection<T> coll) {
//        for (Iterator<T> i = coll.iterator(); i.hasNext();) {
//            System.out.println(i.next());
//        }
//    }
}

泛型示例2

二、Map集合:存储键值对元素

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

 public class MapDemo {
     public static void main(String[] args) {
         MapFunctionDemo();
         MapKeySetFunction();
         MapEntrySetFunction();
         }

     public static void MapFunctionDemo() {
         Map<Integer,String> m=new HashMap<Integer,String>();
         //设置
         System.out.println(m.put(1,"asd"));
         System.out.println(m.put(1,"dada"));
         m.put(2,"vtr");
         m.put(3,"sg");
         System.out.println("m="+m);
         //删除
         int num=2;
         System.out.println("删除掉"+num+"号元素："+m.remove(2));
         System.out.println("m="+m);
         //判断
         System.out.println("m中存在3号元素是"+m.containsKey(3));
         //获取
         System.out.println("m中3号元素是"+m.get(3));
     }

     public static void MapKeySetFunction() {
         /*Map中没有迭代器,不能直接获取所有值,但是可以间接获取。使用KeySet()获取的原理
          * 1、使用KeySet获取所有键所在的Set集合,！！！这些键在Set集合中的排列完全依靠Set的特点
          * 2、通过Set集合的迭代器获取所有键
          * 3、通过键获取对应值
          */
         Map<Integer,String> m=new HashMap<Integer,String>();
         m.put(3,"asd");
         m.put(2,"gf");
         m.put(1,"ju");
         m.put(4,"cvby");
         Set<Integer> s=m.keySet();
         for (Iterator<Integer> i = s.iterator(); i.hasNext();) {
             Integer integer =i.next();
             System.out.println(integer+"..."+m.get(integer));
         }
     }

     public static void MapEntrySetFunction() {
         /*第二种获取所有值的方法是使用entrySet(),返回Set集合,其中的数据类型是Map.Entry<k,v>
          * Map.Entry说明Entey是Map的内部接口。
          * ！！！而这个接口的方法是static的,所以可以被直接使用。
          */
         Map<Integer,String> m=new HashMap<Integer,String>();
         m.put(3,"asd");
         m.put(2,"gf");
         m.put(1,"ju");
         m.put(4,"cvby");
         Set<Map.Entry<Integer,String>> s=m.entrySet();
         for (Iterator<Map.Entry<Integer,String>> i = s.iterator(); i.hasNext();) {
             Entry<Integer, String> entry = i.next();
             Integer age=entry.getKey();
             String name=entry.getValue();
             System.out.println(age+"..."+name);
         }
     }
 }

 //内部接口和内部类的形式非常相近
 interface myMap{
     public static interface myEntry{
         void show();
     }
 }
 class myMapDemo implements myMap.myEntry{
     @Override
     public void show() {
         System.out.println("实现了内部接口");
     }
 }

Map练习

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

 import com.lll.cn.Person;

 public class SubMapDemo {
     public static void main(String[] args){
         HashMapDemo();
         TreeMapDemo();
         MapTest();
     }

     public static void HashMapDemo() {
         //具有Hash特点:即唯一性
         HashMap<Person,String> hm=new HashMap<Person,String>();
         hm.put(new Person(21,"cio"), "河南");
         hm.put(new Person(24,"asdf"), "安徽");
         hm.put(new Person(22,"byee"), "黑龙江");
         hm.put(new Person(23,"cf"), "黑龙江");
         Set<Person> sp=hm.keySet();
         for (Iterator<Person> i = sp.iterator(); i.hasNext();) {
             Person p = i.next();
             String address=hm.get(p);
             System.out.println(p+"..."+address);
         }
     }

     private static void TreeMapDemo() {
         //具有Tree特点:需要排序
         TreeMap<Person,String> tm=new TreeMap<Person,String>(new ComparatorByName());
         tm.put(new Person(21,"cio"), "河南");
         tm.put(new Person(24,"asdf"), "安徽");
         tm.put(new Person(22,"byee"), "黑龙江");
         tm.put(new Person(23,"cf"), "黑龙江");
         Set<Map.Entry<Person,String>> s=tm.entrySet();
         for (Iterator<Map.Entry<Person,String>> i = s.iterator(); i.hasNext();) {
             Entry<Person, String> entry = i.next();
             Person p=entry.getKey();
             String address=entry.getValue();
             System.out.println(p+"..."+address);
         }
     }

     private static void MapTest() {
         /*记录字串中每个字符出现的次数,思路:最后结果是字符和个数相对应,可以使用Map集合来保存
          * 所以可以遍历字串,key为字符,value为个数,遇到某个字符,个数就+1
          */
         String s="adsfkhukvjj";
         Map<Character,Integer> m=new HashMap<Character,Integer>();
         for (int i = 0; i < s.length(); i++) {
             Character curr=s.charAt(i);
             if(m.containsKey(curr)){
                 int num=m.get(curr);
                 m.put(curr, num+1);
             }else{
                 m.put(curr, 1);
             }
         }
         Set<Map.Entry<Character,Integer>> set=m.entrySet();
         for (Iterator<Map.Entry<Character,Integer>> i = set.iterator(); i.hasNext();) {
             Entry<Character,Integer> entry = i.next();
             Character word=entry.getKey();
             Integer num=entry.getValue();
             System.out.println(word+"..."+num);
         }
     }
 }

Map子类练习

三、集合框架工具类

1、Collections类用于对collection(或者是子类List/Set)或Map进行操作。例如

　　1、List中元素进行排序,不能使用Tree结构,因为允许重复元素,此时就可以使用Collections中的sort()进行排序。

　　2、binarySerach()可以对List结构进行二分查找元素,min()/max()可以获取Collection的最值

　　3、reverseOrder()返回一个比较器,可以对Tree结构拍好的顺序进行逆序；reverse()可以对List进行逆序操作

　　4、shuffle()可以对List中元素进行随机排序

　　5、还可以对非同步的Collection/List/Set/Map进行同步操作。synchronized类型

2、Arrays类专门用于操作数组

　　1、binarySerach()二分查找,sort()排序

　　2、copyOf()将数组复制到指定数组,长则补0/null(自动),短则截取;copyOfRange()复制数组一部分到指定数组

　　3、equals()比较数组是否相等

　　4、fill()将指定内容填充数组

　　重点方法:

　　5、asList()将数组转为List：因为数组功能太少，注意：

　　　　1、数组长度固定,所以即使转换为List,其中的增删方法也不能使用

　　　　2、由于集合中只能存放引用类型数据：如果数组中是引用类型则可以直接存入集合中;如果是基本类型则会将数组作为元素整体存入，

四、集合在1.5版本后新特性:

 import java.util.ArrayList;
 import java.util.List;

 public class JDK5new {
     public static void main(String[] args){
         //本部分是说明1.5版本的一些新特性
         //新的for循环
         newfor();
         //不定参数的使用
         System.out.println(somePara(1,1,2,3));
         System.out.println(somePara(1,1,2,3,4));
         //
     }

     public static void newfor() {
         /*1.5版之后的高级for循环主要是简化集合和数组的遍历操作,
          * 参数是  类型  变量:集合名,然后就可以用变量读取数组/集合中的元素
          * 注意:新的for循环目的是用于遍历简单,但是不能取代原来的for循环
          */
         List<String> l=new ArrayList<String>();
         l.add("asd");
         l.add("fg");
         l.add("rrret");
         for(String i:l){
             System.out.println(i);
         }
     }

     private static int somePara(int a,int... arr) {
         /*Java函数中不定参数的解决方法
          * 1、重载函数
          * 2、使用数组接收参数
          * 3、使用1.5版之后的新方法,就像该方法的参数一样,
          *         优点是直接可以向函数传入多个int型数据,会自动将参数封装为数组
          *         ！！！注意除了这个数组之外还有其他参数时,这个参数应该放在最后
          */
         int sum=0;
         for (int i = 0; i < arr.length; i++) {
             sum+=arr[i];
         }
         return sum;
     }
 }

JDK5new

五、其他常用基础类：、

1、System:包含一些有用的类字段和方法。它不能被实例化,其中属性和方法都是static的。

 import java.util.Properties;
 import java.util.Set;

 public class SystemDemo {
     private static final String LINE_SEPARATOR=System.getProperty("line.separator");
     public static void main(String[] args){
         currentTime();
         getProperties();
         demo();
     }

     public static void currentTime() {
         //获取现在的时间毫秒值,起点是1970.1.1
         long l=System.currentTimeMillis();
         System.out.println(l);
     }

     public static void getProperties() {
         /*System.getProperties()获取当前系统的有关信息,返回一个Properties类型数据
          * ！！！该类型是HashTable的子类,也就是键值对组合,并且键和值必须是String类型,所以不使用泛型
          * ！！！注意Properties集合遍历时,使用的是自身的方法而不是继承的方法
          */
         //除了可以使用系统提供的信息,还可以自己添加一些信息,是全局性的,方便使用
         System.setProperty("myKey", "myValue");
         Properties prop=System.getProperties();
         Set<String> nameSet=prop.stringPropertyNames();
         for(String name:nameSet){
             String value=prop.getProperty(name);
             System.out.println(name+":"+value);
         }
     }

     public static void demo() {
         /*在不同系统下,有一些地方是不同的,例如换行符,windows下是\r\n,而UNIX下是\n
          * 如果将文件中使用的换行符全都固定写法,则更换系统时可能出现问题
          * Java在运行时会判断系统,并获取系统信息,可以用这些信息来替屏蔽掉系统,提高兼容性
          */
         System.out.println("hello"+LINE_SEPARATOR+"world");
     }
 }

System示例

2、Runntime：典型的单例类,私有构造器且有非静态方法,

3、Math:执行数学运算的类，Random:随机数发生器类。Math中也有生成随机数的方法,但是只能是double类型,而Random类功能更强大。

4、Date类是日期类,但是其中很多方法已经过时,转而使用Calender类。DateFormat抽象类用于格式化一个日期/时间的格式,但是其中有静态工厂方法可以获取实例对象;也可以用simpleDateFormat类来进行自定义格式化。

 import java.text.DateFormat;
 import java.text.ParseException;
 import java.util.Date;

 public class DateDemo {
     public static void main(String[] args) throws ParseException{
         demo();
         FormatDemo();
         parseDemo();
         CalenderDemo();
     }

     public static void demo() {
         long now=System.currentTimeMillis();
         Date d=new Date(now);
         System.out.println(d);
     }

     public static void FormatDemo() {
         //日期/时间的格式化使用的是DateFormat类,抽象类,不能直接实例化
         long now=System.currentTimeMillis();
         Date d=new Date(now);
         //！！！传入不同的参数对应不同的格式,解析时该格式的对象只能解析对应的字符串,见下
         DateFormat df=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
         String date=df.format(d);
         System.out.println(date);
     }

     public static void parseDemo() throws ParseException {
         //还可以将一个表示日期时间的字符串转换为Date对象,默认只能解析以-分隔的
         String str_date="2105年4月25日";
         //！！！这里的参数是年/月/日分隔的时间格式,所以可以解析这种格式的 字符串
         DateFormat df=DateFormat.getDateInstance(DateFormat.LONG);
         Date date=df.parse(str_date);
         System.out.println(date);
     }

     public static void CalenderDemo() {
         //Calender类是将日期以键值对保存,且是字符串格式
     }
 }

时间有关类演示