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());
//        }
//    }
}

二、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("实现了内部接口");
    }
}

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);
        }
    }
}

三、集合框架工具类

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;
    }
}

五、其他常用基础类：、

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下是
,而UNIX下是

         * 如果将文件中使用的换行符全都固定写法,则更换系统时可能出现问题
         * Java在运行时会判断系统,并获取系统信息,可以用这些信息来替屏蔽掉系统,提高兼容性
         */
        System.out.println("hello"+LINE_SEPARATOR+"world");
    }
}

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类是将日期以键值对保存,且是字符串格式
    }
}