正文

java基础--泛型集合io反射

 2022-03-25  445

关键词：

计划把 Java 基础的有些部分再次看一遍，巩固一下，下面以及以后就会分享自己再次学习的一点笔记！不是有关标题的所有知识点，只是自己觉得模糊的一些知识点。

1.　　对于泛型类而言，你若没有指明其类型，默认为Object；

2.　　在继承泛型类以及接口的时候可以指明泛型的类型，也可以不指明；

3. 　　泛型也数据库中的应用：

　　　　　　写一个 DAO 类对数据库中的数据进行增删改查其类型声明为 <T> 。每张表对应一个类，对应每一张表实现一个类继承该 DAO 类并指明 DAO 泛型为该数据表对应的类，再实现一个与该表匹配的 DAO 操作类，这样就不必在每一个数据表的操作实现类中去实现增删改查的基本方法。例如（实际应用中大概就是这思想，下面的举例并不完整）：

 1 //数据表对应的类
 2 public class Customer{
 3     private int id;
 4     private String name;
 5     ...
 6 }
 7 
 8 //所有数据表的操作类都要实现的 DAO 基类
 9 public class DAO<T> {
10     //增
11     public void add(T t) {
12     …
13     ｝
14 }
15 
16 public T get(int index) {
17     //查
18     return null;
19 }
20 
21 public void delete() {
22     //删
23     …
24 }
25 
26 public List<T> getForList(int index) {
27     //查
28     return null;
29 }
30 
31 //数据表操作对应的实现类
32 public class CustomerDao extends DAO<Customer> {
33                 
34 }
35 
36 //测试类
37 public class Test {
38     public static void mian(String[] args) {
39     CustomerDao cus = new CustomerDao;
40     Cus.add(new Customer);
41     }
42 }

View Code

4. 　　静态方法中不可以使用泛型（static）

　　　　　　因为static 声明的方法或者类以及变量都是在类初始化的时候初始化，而泛型是在运行的时候才回去初始化的，所以就出现了问题（后出现的调用了先出现的）。

public T t;
    //Error
    public static void show() {
        System.out.println(t);
}

View Code

5.　　通配符

　　　　　　可以读取声明为通配符的集合，但不可往里写入元素（读的时候可以把元素都认为是 Object，但写的时候其声明为？，不是 Object，也就是说写什么类型都是错的，但可以存 null），例如

Public void testList() {
    List<String> strList = new ArrayList<>();
    strList.add(“Hello”);
    strList.add(“World”);

    //correct
    List<?> list = strList;
    
    //error
    list.add(“hi”);
    list.add(123);
    //correct
    list.add(null);
}

View Code

6.　　集合Map 的遍历

package com.java.map.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapEntry {

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        // 得到 map 所有键的集合
        Set<Integer> keys = map.keySet();

        for (Integer key : map.keySet()) {
            System.out.println(map.get(key));
        }

        // 利用迭代器 遍历
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // 第三种
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }

        // 遍历所有的 value 值
        Collection<String> values = map.values();

        for (String val : values) {
            System.out.println(val + ">>-");
        }

        Iterator<String> i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next() + "-->");
        }

        List<String> lists = new ArrayList<>();
        lists.add("1");
        lists.add("2");
        lists.add("3");
        lists.add("4");

        Iterator<String> it2 = lists.iterator();

        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
        
        Collections.reverse(lists);
        Iterator<String> it3 = lists.iterator();
//        Comparator comparator = new 
        
        
        while (it3.hasNext()) {
            System.out.println(it3.next() + "<->");
        }
    }
}

View Code

7.　　利用反射获取方法名和属性名，利用反射还可以获取构造器等其他信息

package com.java.reflct.test;

//实体类
public class Person {

    private String id;
    
    private String name;
    
    public int phone;
    
    public void setId(String id) {
        this.id = id;
    }
    
    public String getId() {
        return id;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setPhone(int phone) {
        this.phone = phone;
    }
    
    public int getPhone() {
        return phone;
    }
    
    private void print() {
        System.out.println("your id is " + id + ", your name is " + name + ", your phone is " + phone + "!");
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", phone=" + phone + "]";
    }
}

package com.java.reflct.test;
//测试类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) {
        try {
//            通过 Class.forName("全类名"); 获取 Class，还以利用  对象名.getClass()  类名.class(); 获取Class
            Class cla = Class.forName("com.java.reflct.test.Person");
            Class cla2 = Person.class;
            
//            获取所有的 变量，返回数组，包括私有变量
            Field[] fields = cla2.getDeclaredFields();
//            遍历变量数组
            for (Field fie : fields) {
                System.out.println(fie+"-..-");
            }
            
//            获取所有的方法，返回数组，包括私有方法
            Method[] methods = cla.getDeclaredMethods();
            
            for (Method met : methods) {
                System.out.println(met);
            }
            
            try {
//                获取单个私有属性
                Field field = cla.getDeclaredField("id");
//                打破封装
                field.setAccessible(true);
                System.out.println(field + "<<>>");
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            Method method = null;
            
            try {
//                获取单个私有方法
                method = cla.getDeclaredMethod("print");
//                打破封装
                method.setAccessible(true);
                System.out.println(method + ">><<");
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            try {
//                通过cla.newInstance(); 获取类的对象
                Person person = (Person) cla.newInstance();
                person.setId("1");
                person.setName("yinyin");
                person.setPhone(110);
                
                System.out.println(person + "__>>__");
                try {
//                    执行 person 对象的中 method 所对应的方法
                    method.invoke(person);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InstantiationException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            
            
        } catch(ClassNotFoundException e) {
            System.out.println("There is no class " + e);
        }
    }
}

View Code

8.　　Comparator 类的使用（利用 Comparator 实现集合的自定义排序）

　　　　　　注意区分 Collections （集合的处理类）和 Collection （集合基类）

package com.java.collection.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/*
 * Collections 是 Collection 的操作类
 */

public class CollectionComparator {
    
    public static void main(String[] args) {
        
        Comparator<Customer> com = new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中，使得 id 相等时有其他的处理方法
                int i = o1.getId().compareTo(o2.getId());
                
//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
//                    给 return 添加一个 - 号可以实现 “从大到小”
                    return o1.getName().compareTo(o2.getName());
                }
//                                    Id 不相等时返回其值        
                                   return i;
            }
        };
        
        List<Customer> lists = new ArrayList<>();
        lists.add(new Customer("yinyin", "110", 1001));
        lists.add(new Customer("zhao", "10086", 1002));
        lists.add(new Customer("ls", "10010", 1001));;
        
        Collections.sort(lists, com);
        
//        利用匿名类实现自定义排序
        /*
        Collections.sort(lists, new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                将 id 的比较值放入参数中，避免 id 相等没有其值
                int i = o1.getId().compareTo(o2.getId());
                
//                当 Id 相等的时候比较名字的顺序
                if (i == 0) {
                    return o1.getName().compareTo(o2.getName());
                }
                return i;
            }
        });
        */
 //利用迭代器遍历集合
        Iterator<Customer> it = lists.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        
    }
}

View Code

9.　　IO

　　　　　　读取目标文本文件的字节数

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class MyIoTest {

    public static void main(String[] args) {
        
//        在 IO 中出现的异常最好都使用 try-catch 包裹起来，不要 throw，因为这样可以保证流的关闭在任何时候都可以正常执行
        InputStream fileStream = null;
        int count = 0;
        try {
            fileStream = new FileInputStream(new File("hello.txt"));
//            读取文件的下一个字节
            while (fileStream.read() != -1) {
                count++;
            }
//            打印目标文件的字节数
            System.out.println(count);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

　　　　　　实现文件的复制（InputStream 、OutputStream 和 Reader 、Writer）。文本文件的操作使用 Reader Writer（字符流）去实现，效率高。但是不可以去操作媒体文件；媒体文件使用 InputStream OutputStream 去实现，也可以对文本文件进行操作，但是没有字符流高效。

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyFile {

    public static void main(String[] args) {
//        设置一次从目标文件中读取多少字节
        byte[] buffer = new byte[1024];

        int len = 0;
        File file = new File("C:/Users/lenovo/Desktop/123.wmv");
        InputStream fileInput = null;
        OutputStream fileOut = null;

        try {
            fileInput = new FileInputStream(file);
            fileOut = new FileOutputStream(new File("C:/Users/lenovo/Desktop/trave2.wmv"));

//            len 的作用是防止读取文件时最后一次其长度不够读取被置为零，read() 返回读入缓冲区的字节总数
            while ((len = fileInput.read(buffer)) != -1) {
                fileOut.write(buffer, 0, len);
            }
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileOut.close();
                fileInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}





//利用 Reader Writer 实现
package com.java.io.file.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class ReaderWriter {

    public static void main(String[] args) {
        File file = new File("hello.txt");
        int len = 0;
        Reader fileReader = null;
        Writer fileWriter = null;
        char[] ch = new char[125];
        
        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(new File("world.txt"));
            
            while((len = fileReader.read(ch)) != -1) {
                fileWriter.write(ch, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

10.　　利用缓冲流实现文件的复制操作，效率更高

package com.java.io.file.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TestBufferedCopy {
// 使用缓冲流实现文件的复制
    public static void main(String[] args)  {
        
        int len = 0;
        byte[] buffer = new byte[2048];
        
        File file = new File("C:/Users/lenovo/Desktop/123.rmvb");
        InputStream inputFile = null;
        OutputStream outputFile = null;

        BufferedInputStream bufferedInput = null;
        BufferedOutputStream bufferedOutput = null;
        
        try {
            inputFile = new FileInputStream(file);
            outputFile = new FileOutputStream("C:/Users/lenovo/Desktop/456.rmvb");
            
            bufferedInput = new BufferedInputStream(inputFile);
            bufferedOutput = new BufferedOutputStream(outputFile);
            
            while((len = bufferedInput.read(buffer)) != -1) {
                bufferedOutput.write(buffer, 0, len);
            }
            
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
//                只需关闭复制文件用到的就可以，即最后两个
                bufferedOutput.close();
                bufferedInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

上面的代码总结啥的都是自己平常练习过程中的代码和心得，对于知识点讲解覆盖的并不全面，还望谅解。初来乍到不知道该如何去写！

通过反射了解集合泛型的本质

通过反射了解集合泛型的本质importjava.lang.reflect.Method;importjava.util.ArrayList;/***通过反射了解集合泛型的本质*@authorshm**/publicclassMethodDemo02{ publicstaticvoidmain(String[]args){ ArrayListlist=newArrayList(); list.a 查看详情

java-基础（集合泛型）(代码片段)

JAVA-基础（集合泛型）1.什么是泛型？可以在类或方法中预支地使用未知的类型。2.泛型的好处？将运行时期的ClassCastException，转移到了编译时期变成了编译失败。避免了类型强转的麻烦。（集合中是可以存放任意对象的，只要把... 查看详情

实用的java反射工具类

...技术A　　反射的Utils函数集合　　提供访问私有变量获取泛型类型Class提取集合中元素的属性等Utils函数　　packagereflection　　importjavalangreflectFieldimportjavalangreflectModifierimportjavalangreflectParameterizedTypeimportjavalangreflectTypeimportjavautilArr... 查看详情

java基础_集合泛型

泛型1.泛型概述我们在集合中存储数据的时候，存储了String和Integer俩种类型的数据。而在遍历的时候，我们把它当做是String类型处理，做了转化，所以会报错。但是呢?它在编译期间却没有告诉我们。所以我们觉得这一个设计的... 查看详情

java专栏

第一章Java基础Java专题零：对象初始化顺序Java专题一：数据类型Java专题二：相等与比较Java专题三：集合Java专题四：异常Java专题五：遍历与迭代Java专题六：运算符Java专题七：正则表达式Java专题八：泛型Java专题九：反射Java专题... 查看详情

[java基础]反射练习之越过泛型检查，运行配置文件制定内容(代码片段)

代码如下:packageReflectTest01;importjava.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;importjava.util.ArrayList;publicclassReflectTest01publicstaticvoidmain(String[]args)throwsNo 查看详情

java学习路线图

Java的学习路线图，整理以备自己学习和温习。1.Java基础　　具体内容：　　　　1. 编程基础（开发环境配置、基础语法、基本数据类型、流程控制、常用工具类）　　　　2. 面向对象（继承、封装、多态、抽象类、接口... 查看详情

java基础--常用api--集合类相关api(代码片段)

一、泛型　　1、泛型的本质是将类型参数化，即将数据类型作为参数。　　　2、泛型可以在编译期进行检查，其所有的强制转换是隐式且自动的，提高了代码的安全性。　　　　3、泛型可以用在类（泛型类）、接口（泛型接口... 查看详情

java基础系列--08_集合1

---恢复内容开始---集合当中有很多都是应用到泛型的技术，所以在讲集合之前，应该先将泛型的概念普及一下。泛型： (1)泛型是一种类型，但是这种类型是在编译或者调用方法时才确定。 (2)格式： ... 查看详情

java基础

（一）泛型（1）数组直接定义了存储的类型,防止出现其他类型的元素,集合能不能也像数组一样,直接规定我们集合的存储类型,针对这种情况一种技术:泛型<数据类型>---引用数据类型泛型:将明确的集合类型的工作推迟到了创... 查看详情

《java架构筑基》从java基础讲起——泛型基础

一.泛型的概述1.1泛型由来我们的集合可以存储多种数据类型的元素,那么在存储的时候没有任何问题,但是在获取元素,并向下转型的时候,可能会存在一个错误,而这个错误就是ClassCastException.很显然,集合的这种可以存储多种数据类... 查看详情

博文目录

java基础反射注解代理泛型异常IONIOObject类JVM内存模型类加载机制调优Tomcat调优java并发JMMvolatilesynchronizedlockAQSCondition线程池原理java集合java集合架构概况HashMapArrayListLinkedListHashSetTreeSetHashTable设计模式设计模式总览，创建型，结构... 查看详情

《java基础系列》初步整理

《Java基础系列》初步整理大概有12篇，主要内容为。：抽象类和接口内部类修饰符装箱拆箱注解反射泛型异常集合IO字符串其他第一篇我们来聊聊抽象类和接口。“抽象类和接口”听起来是非常普遍的东西，有些朋友会觉得：这... 查看详情

java基础第十二篇之集合增强for循环迭代器和泛型

Collection接口中的常用方法:* 所有的子类子接口都是具有的*集合的方法:增删改查** publicbooleanadd(Ee);//添加元素返回值表示是否添加成功* publicbooleanremove(Objecto);//删除元素,返回值表示是否删除成功* 没有修改方法* 查询元素的... 查看详情

学习笔记导航

韩顺平教育循序渐进学Java零基础第01-08章Java基础语法第10章面向对象编程(高级部分)第11章枚举和注解第12章异常第13章常用类第14章集合第15章泛型第17章多线程编程第19章IO流第21章网络编程第23章反射第24章零基础学MySQL第25章JDBC... 查看详情

学习笔记导航

java反射基础知识反射应用实践

Java除了给我们提供在编译期得到类的各种信息之外，还通过反射让我们可以在运行期间得到类的各种信息。通过反射获取类的信息，得到类的信息之后，就可以获取以下相关内容：Class对象构造器变量方法私有变量与私有方法注... 查看详情

java基础语法java的泛型和包装类(代码片段)

前言：本章主要是为了后面学习集合框架所做的知识补充。补充了泛型以及包装类两个知识，但是该章泛型的讲解不够全面，主要是为了集合框架学习做铺垫。文章目录1.预备知识-泛型（Generic）1.1泛型的引入1... 查看详情