Java-day25（泛型与File）

最新推荐文章于 2022-03-01 17:27:03 发布
最新推荐文章于 2022-03-01 17:27:03 发布
阅读量371 收藏 3
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742328/article/details/109123797
版权

泛型的概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在集合中使用泛型

/**
 * 泛型的使用
 * 1.JDK5.0新增的特性
 *
 * 2.在集合中使用泛型
 * 总结：① 集合接口或集合类在JDK5.0时都修改为带泛型的结构
 *      ② 在实例化集合类时，可以指明具体的泛型类型
 *      ③ 指明完以后，在集合类或接口中凡是定义类或接口时，
 *        内部结构(比如：方法、构造器、属性等)使用到类的
 *        泛型位置，都指定为实例化的泛型类型
 *        比如：add(E e) → 实例化以后：add(Integer e)
 *      ④注意点：泛型的类型必须是一个类，不能是基本数据类型，
 *              需要用到基本数据的类型时，用包装类代替。
 *      ⑤如果实例化时，没有指明泛型的类型。
 *       默认类型java.lang.Object类
 *
 * @author acoffee
 * @create 2020-10-16 18:35
 */
public class acoffee {

    @Test
    public void test(){
        ArrayList<Integer> list = new ArrayList<>();

        list.add(77);
        list.add(78);
        list.add(79);
        list.add(76);
        //编译时会报错
        //list.add("da");

        for (Object score:list){
            int stuScore = (Integer)score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test2(){

        //HashMap<String, Integer> map = new HashMap<String, Integer>();
        //JDK7类型推断
        HashMap<String, Integer> map = new HashMap<>();

        map.put("Tom",23);
        map.put("Jerry",22);
        map.put("Frank",27);
        map.put("Tom",23);

        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        Iterator<Map.Entry<String,Integer>> iterator= entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "----" + value);

        }
    }
}

自定义泛型结构

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型。（因为泛型实例化的时候指定的）

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
在这里插入图片描述
在这里插入图片描述

OrderGeneric类（自定义泛型类）：

/**
 * 自定义泛型类
 * @author acoffee
 * @create 2020-10-16 19:54
 */
public class OrderGeneric<T> {

    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT;

    public OrderGeneric(){};

    public OrderGeneric(String orderName,int orderId,T orederT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orederT;
    }

    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "OrderGeneric{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", oredrT=" + orderT +
                '}';
    }
}

SubOrder类（继承OrderGeneric类 并指明 了泛型的类型）：
我们此时就不需要再在SubOrder中去声明泛型类型，即SubOrder类不是泛型类

/**
 * 继承OrderGeneric类
 * @author acoffee
 * @create 2020-10-16 20:23
 */
public class SubOrder extends OrderGeneric<Integer> {
}

SubOrder1类（继承OrderGeneric类 不指明 泛型的类型）：
不去指明OrderGeneric的泛型类型，此时SubOrder1仍然是泛型类

/**
 * 不去指明OrderGeneric的泛型类型
 * @author acoffee
 * @create 2020-10-16 20:28
 */
//此时SubOrder1仍然是泛型类
public class SubOrder1<T> extends OrderGeneric<T> {

}

GenericTest 类（测试类）：

public class GenericTest {

    @Test
    public void test1(){
    //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
    //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型
        //不指明泛型的情况：
        OrderGeneric order = new OrderGeneric();
        order.setOrderT(123);
        order.setOrderT("abc");


        //建议带上泛型
        OrderGeneric<String> stringOrderGeneric = new OrderGeneric<>("orderAA",1001,"order:AA");
        order.setOrderT("AA:hello");
    }


    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化
        //子类对象时，不在需要指明泛型
        sub1.setOrderT(12);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("hello");
    }

自定义泛型结构：泛型方法

在这里插入图片描述
copyFromArrayToList类：

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
    //换句话说，翻新方法所属的类是不是泛型类都没有关系
    //泛型 方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定
    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e: arr){
            list.add(e);
        }
        return list;

    }

test类（测试类）：

 //测试泛型方法
    @Test
    public void test4(){
        OrderGeneric<String> order = new OrderGeneric<>();
        Integer[] arr = {1, 23, 4, 5};
        //泛型方法在调用时，指明返现参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);//[1, 23, 4, 5]
        }

泛型类的使用情景

加入我们要处理数据库中不同的表格，一个表格就相当于一个类，这个时候我们就用到了泛型。

DAO类：

public class DAO<T> {//表的共性操作的DAO

    //添加一条记录
    public void add(T t){

    }

    //删除一条记录
    public boolean remove(int index){

        return false;
    }

    //修改一条记录
    public void update(int index,T t){

    }

    //查询一条记录
    public T getIndex(int index){

        return null;
    }

    //查询多条记录
    public List<T> getForList(int index){

        return null;
    }

    //泛型方法
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){

        return null;
    }

}

Customer类：

public class Customer { //此类对应数据库中的customers表
}

Student 类：

public class Student {//此类对应数据库中的Student表
}

CustomerDAO 类（继承DAO类）：

public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}

StudentDAO 类（继承DAO类）：

public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
}

DAOTest 类（测试类）：

public class DAOTest {

    @Test
    public void test1(){
        CustomerDAO dao1 = new CustomerDAO();

        dao1.add(new Customer());
        List<Customer> list = dao1.getForList(10);


        StudentDAO dao2 = new StudentDAO();
        Student student = dao2.getIndex(1);
    }
}

泛型在继承方面的体现

在这里插入图片描述

/**
 * 泛型在继承方面的体现
 *
 * @author acoffee
 * @create 2020-10-17 9:38
 */
public class GenericTest {
    /*
1. 泛型在继承方面的体现

  虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。

   补充：类A是类B的父类，A<G> 是 B<G> 的父类

 */
    @Test
    public void test1() {

        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;
        //编译不通过
//        Date date = new Date();
//        str = date;
        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
//        list1 = list2;
        /*
        反证法：
        假设list1 = list2;
           list1.add(123);导致混入非String的数据。出错。

         */

        show(list1);
        show1(list2);

    }


    public void show1(List<String> list) {

    }

    public void show(List<Object> list) {

    }

    @Test
    public void test2() {

        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();

    }

通配符的使用

在这里插入图片描述
在这里插入图片描述

 //通配符的使用，通配符：？
    //类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
    @Test
    public void test3() {
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;

//        print(list1);
//        print(list2);

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;
        //添加(写入)：对于List<?>就不能向其内部添加数据。
        //除了添加null之外。
//        list.add("DD");
//        list.add('?');

        list.add(null);

        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
    }

public class WildcardCharacterTest {
	public static void main(String[] args) {
		ArrayList<String> arrayList = new ArrayList();
		arrayList.add("aaa");
		arrayList.add("bbb");
		arrayList.add("ccc");
		Test(arrayList);
	}

	public static void Test(ArrayList<?> list) {
		// 我们指定的ArrayList为String类型，但是我们在形参中
		// 指定类型为通配符，这种写法就不能对集合更改和添加操作，
		// 只能遍历、删除和取值
		for (Object str : list) {
			System.out.println(str);//aaa bbb ccc
		}
		System.out.println();
//		list.add("aaa");
//		list.set(1, "bbb");
		list.remove(1);

		System.out.println(list.get(1));//ccc
		System.out.println();
		for (Object str : list) {
			System.out.println(str);//aaa ccc
		}
	}
}

有限制的通配符
在这里插入图片描述

    /*
    3.有限制条件的通配符的使用。
        ? extends A:
                G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

        ? super A:
                G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

     */
    @Test
    public void test4(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过
        //Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());

        //编译通过
        list2.add(new Person());
        list2.add(new Student());

    }

自定义泛型类练习：

DAO类（工具类）：

package com.acoffee.exer1;

import java.util.*;

/**
 * 定义个泛型类 DAO<T>，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。
 * <p>
 * 分别创建以下方法：
 * public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中
 * public T get(String id)：从 map 中获取 id 对应的对象
 * public void update(String id,T entity)：替换 map 中key为id的内容,改为 entity 对象
 * public List<T> list()：返回 map 中存放的所有 T 对象
 * public void delete(String id)：删除指定 id 对象
 *
 * @author acoffee
 * @create 2020-10-17 11:20
 */
public class DAO<T> {

    private Map<String, T> map = new HashMap<String, T>();

    //保存 T 类型的对象到 Map 成员变量中
    public void save(String id, T entity) {

        map.put(id,entity);
    }

    //从 map 中获取 id 对应的对象
    public T get(String id) {
        return map.get(id);
    }

    //替换 map 中key为id的内容,改为 entity 对象
    public void update(String id, T entity) {
        if (map.containsKey(id)){//先查看里面有没有id，没有就不用修改了
            map.put(id,entity);
        }
    }

    //返回 map 中存放的所有 T 对象
    public List<T> list() {
        //错误的
        //Collection<T> values = map.values();
        //return  (List<T>)values;

        ArrayList<T> list = new ArrayList<>();
        Collection<T> values = map.values();

        for (T t:values){
            list.add(t);
        }
        return list;
    }

    //删除指定 id 对象
    public void delete(String id) {
        map.remove(id);
    }
}

User类（构造器及get 、set方法）：

package com.acoffee.exer1;

/**
 * 定义一个User类：
 * 该类包含：private成员变量（int类型）id，age; （String类型）name。
 *
 * @author acoffee
 * @create 2020-10-17 11:36
 */
public class User {
    private int id;
    private int age;
    private String name;

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public User() {

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

DAOTest类（测试类）：

package com.acoffee.exer1;

import java.util.List;

/**
 * 创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方法来操作 User 对象，
 *  使用 Junit 单元测试类进行测试。
 * @author acoffee
 * @create 2020-10-17 11:41
 */
public class DAOTest {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<User>();
        dao.save("1001", new User(1001, 34, "周杰伦"));
        dao.save("1002", new User(1002, 20, "JJ"));
        dao.save("1003", new User(1003, 33, "蔡依林"));

        dao.update("1003", new User(1003, 30, "方文山"));

        dao.delete("1002");

        List<User> list = dao.list();
        list.forEach(System.out::println);
    }
}

File类的使用

在这里插入图片描述
File 类的使用：常用构造器

在这里插入图片描述
在这里插入图片描述
路径的分类：
相对路径：相较于某个路径下，指明的路径
绝对路径：包含盘符再累的文件或文件目录的路径

说明：
IDEA中：
如果大家开发中使用JUnit中的单元测试方法测试，相对路径即为当前Moudule下。
如果大家使用main( )测试，相对路径即为当前的Project下。
Eclipse中：
不管当前使用单元测试还是使用main( ) 测试，相对路径都是当前的Project下。

/**
 * 1.如何创建File类的实例
 *  File(String filePath)
 *  File(String filePath,String filePath)
 *  File(File parentFile,String filePath)
 *
 * 2.相对路径：相较于某个路径下，指明的路径
 *   绝对路径：包含盘符再累的文件或文件目录的路径
 *
 * 3.路径分隔符
 *    windows：\\
 *    unix:/
 *
 * @author acoffee
 * @create 2020-10-17 15:24
 */
public class FileTest {
    @Test
    public void test(){
        //构造器1：
        File file = new File("hello.txt");
        File file1 = new File("D:\\code\\workspace-0923\\day25");

        System.out.println(file);//hello.txt
        System.out.println(file1);//D:\code\workspace-0923\day25

        //构造器2：
        File file2 = new File("D:\\code\\workspace-0923", "day25");
        System.out.println(file2);//D:\code\workspace-0923\day25

        //构造器3：
        File file3 = new File(file2, "1.txt");//D:\code\workspace-0923\day25\1.txt
        System.out.println(file3);

    }
}

File 类的使用：常用方法
在这里插入图片描述
File类的获取功能

    /*
public String getAbsolutePath()：获取绝对路径
public String getPath() ：获取路径
public String getName() ：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值

如下的两个方法适用于文件目录：
public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组


     */
    @Test
    public void test2(){
        File file1 = new File("hello.txt");
        File file2 = new File("d:\\io\\hi.txt");

        System.out.println(file1.getAbsolutePath());//D:\code\workspace-0923\day25\hello.txt
        System.out.println(file1.getPath());//hello.txt
        System.out.println(file1.getName());//hello.txt
        System.out.println(file1.getParent());//null
        System.out.println(file1.length());//10
        System.out.println(new Date(file1.lastModified()));//Sat Oct 17 16:17:35 CST 2020

        System.out.println();

        System.out.println(file2.getAbsolutePath());//d:\io\hi.txt
        System.out.println(file2.getPath());//d:\io\hi.txt
        System.out.println(file2.getName());//hi.txt
        System.out.println(file2.getParent());//d:\io
        System.out.println(file2.length());//0
        System.out.println(file2.lastModified());//0
    }
    
    @Test
    public void test3(){
        File file = new File("D:\\workspace_idea1\\JavaSenior");

        String[] list = file.list();
        for(String s : list){
            System.out.println(s);
        }

        System.out.println();

        File[] files = file.listFiles();
        for(File f : files){
            System.out.println(f);
        }

    }

File类的重命名功能

  /*
    public boolean renameTo(File dest):把文件重命名为指定的文件路径
     比如：file1.renameTo(file2)为例：
        要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。
     */
    @Test
    public void test4(){
        File file1 = new File("hello.txt");
        File file2 = new File("D:\\io\\hi.txt");

        boolean renameTo = file2.renameTo(file1);
        System.out.println(renameTo);

    }

File类的判断功能
在这里插入图片描述

    /*
public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

 */
    @Test
    public void test5(){
        File file1 = new File("hello.txt");
        file1 = new File("hello1.txt");

        System.out.println(file1.isDirectory());
        System.out.println(file1.isFile());
        System.out.println(file1.exists());
        System.out.println(file1.canRead());
        System.out.println(file1.canWrite());
        System.out.println(file1.isHidden());

        System.out.println();

        File file2 = new File("d:\\IO");
        file2 = new File("d:\\io1");
        System.out.println(file2.isDirectory());
        System.out.println(file2.isFile());
        System.out.println(file2.exists());
        System.out.println(file2.canRead());
        System.out.println(file2.canWrite());
        System.out.println(file2.isHidden());

    }

File类的创建、删除功能
在这里插入图片描述

	/*
         创建硬盘中对应的文件或文件目录
        public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
        public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
        public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建

         删除磁盘中的文件或文件目录
        public boolean delete()：删除文件或者文件夹
         删除注意事项：Java中的删除不走回收站。
    */
    @Test
    public void test6() throws IOException {
        File file1 = new File("hi.txt");
        if(!file1.exists()){
            //文件的创建
            file1.createNewFile();
            System.out.println("创建成功");
        }else{//文件存在
            file1.delete();
            System.out.println("删除成功");
        }


    }
    @Test
    public void test7(){
        //文件目录的创建
        File file1 = new File("d:\\io\\io1\\io3");

        boolean mkdir = file1.mkdir();
        if(mkdir){
            System.out.println("创建成功1");
        }

        File file2 = new File("d:\\io\\io1\\io4");

        boolean mkdir1 = file2.mkdirs();
        if(mkdir1){
            System.out.println("创建成功2");
        }
        //要想删除成功，io4文件目录下不能有子目录或文件
        File file3 = new File("D:\\io\\io1\\io4");
        file3 = new File("D:\\io\\io1");
        System.out.println(file3.delete());
    }

课后练习

在这里插入图片描述
1.利用File构造器，new 一个文件目录file

public class FileDemo {
    @Test

    //利用File构造器，new 一个文件目录file
    // 1)在其中创建多个文件和目录
    // 2)编写方法，实现删除file中指定文件的操作

    public void test1() throws IOException {
        File file = new File("d:\\io\\io1\\hello.txt");
        //创建一个与file同目录下的另一个文件，文件名为：haha.txt
        File file1 = new File(file.getParent(), "haha.txt");
        boolean newFile = file1.createNewFile();
        if (newFile){
            System.out.println("创建成功");
        }

        //删除haha.txt
        System.out.println(file1.delete());
    }
}

2. 判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

/**
 * 课后练习2：判断指定目录下是否有后缀名为.jpg的文件
 * 如果有，就输出该文件名称
 * @author acoffee
 * @create 2020-10-17 17:49
 */
public class exer2 {
    @Test
    public void test1(){
        File srcFile = new File("D:\\code");

        String[] fileNames = srcFile.list();

        for (String fileName : fileNames){
            if (fileName.endsWith(".jpg")){
                System.out.println(fileName);
            }
        }
    }
}

3.遍历指定目录所有文件名称，包括子文件目录中的文件。

/**
 * 遍历指定目录所有文件名称，包括子文件目录中的文件。
 * @author acoffee
 * @create 2020-10-17 18:36
 */
public class practise3 {
    /* 打印出指定目录所有文件名称，包括子文件目录中的文件 */
    public static void main(String[] args) {
        File dir = new File("D:\\code");

        //打印dir的子目录
        PrintSubFile(dir);
    }

    public static void PrintSubFile(File dir){
        File[] SubFile = dir.listFiles();

        //递归:文件目录
        for (File f:SubFile){
            if (f.isDirectory()){//文件目录
                PrintSubFile(f);
            }else{//文件
                System.out.println(f.getAbsoluteFile());
            }
        }

    }
}

File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。

每日一练:

1.如何遍历Map的key集，value集,key-value集，使用上泛型

Map<String,Integer> map = new HashMap<String,Integer>();
map.put();....
//遍历key
Set<String> keySet = map.keySet();
for(String key : keySet){
	System.out.println(key);
}

//遍历value
Collection<Integer> values = map.values();
Iterator<Integer> iterator = values.iterator();
while(iterator.hasNext()){
	System.out.println(iterator.next());
}

//遍历key-value
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<String,Integer>> iterator =  entrySet.iterator();
while(iterator.hasNext()){
	Map.Entry<String,Integer> entry = iterator.next();
	String key = entry.getKey();
	Integer value = entry.getValue();
	System.out.println(key + "--->" + value);
}

2. 写出使用Iterator 和 增强for 循环遍历List的代码,使用上泛型

@Test
public void test3() {
ArrayList list = new ArrayList<>();
list.add(“qq”);
list.add(“bb”);
list.add(“cc”);
list.add(“aa”);

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

}

3. 提供一个方法，用于遍历获取HashMap<String,String>中的所有value，并存放在List中返回。考虑上集合中泛型的使用。

public List<String> getValueList(HashMap<String,String> map){
	ArrayList<String> valueList = new ArrayList<>():
	Collection<String> values = map.values();
	for(String value : values){
		valueList.add(value);
	}
	return valueList;
}

4. 创建一个与a.txt文件同目录下的另外一个文件b.txt

File file1 = new File("d:\\a\\a.txt");
File file2 = new File(file1.getParent(),"b.txt");

5. Map接口中的常用方法有哪些

增：put(K k,V v)
删: V remove(K k)
改: put(K k,V v)
查: V get(K k)
长度:int size()
遍历

vid。
关注
专栏目录
【技能实训】DMS数据挖掘项目-Day10
兔子王
07-15 281
任务10 【任务10.1.1】安装Mysql数据库，创建项目所需的数据库dms_学号、表及用户名、密码等，并搭建数据访问的基础环境(JDBC) 【任务10.1.2】加载JDBC包 【任务10.1.3】编写mysql.properties文件 【任务10.1.4】编写Config类 【任务10.2】编写访问数据库的工具类DBUtil.java 任务11 【任务11.1】根据项目需求，设计数据库表，用于存储匹配物流数据，要求明确表达出三个匹配物流对象的关系。即发货中、送货中、已签收的对应关系。
File类的学习过程中出现的问题及解决方法
clover_oreo的博客
07-25 755
1.利用File构造器，new一个文件目录file1)在其中创建多个文件和目录，测试自己学过的File类的方法2)手动编写方法，实现删除file中指定文件的操作​2.判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称​3.遍历指定目录所有文件名称，包括子文件目录中的文件（注意这句话，经典递归方法，不知道思路的直接问）。​4.创建一个与a.txt文件同目录下的另外一个文件b.txt​5.操作D盘下的my.txt文件1)判断my.txt文件是否存在。...
Java基础14-java进阶(5)【IO流】
小管博客空间站
11-15 341
Java进阶06 IO流 1 File类 1.1 简介 java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 1.2 常用构造器 public
21、IO流
AlexAuthor7的博客
01-15 360
IO流 目录 一、File类的使用 二、IO流原理及流的分类 三、节点流 四、缓冲流 五、转换流 六、标准输入、输出流 七、打印流 八、数据流 九、对象流 十、随机存储文件流 十一、NIO.2中Path、 Paths、Files类的使用 一、File类的使用 （一）、File类的使用 1、File类的一个对象，代表一个文件或一个文件目录（俗称文件夹） 2、File类声明在Java.io包下 3、相对路径： 绝对路径： 4、并未涉及到写入湖泊读取问价内容的的操作，如果需要读取或写入文件 内容，必须使用IO流
Java进阶（三十四）IO流2：File类的练习
qq_33491651的博客
03-01 596
1.利用File构造器，new一个文件目录file 在其中创建多个文件和目录 编写方法，实现删除file中指定文件的操作 2.判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称 3.遍历指定目录所有文件名称，包括子文件目录中的文件。 并计算指定目录占用空间的大小 删除指定文件目录及其下的所有文件。 ...
JavaSE-IO流-File类的使用
源于热爱的博客
04-18 619
11111111
Java学习day057 泛型类型的继承规则、通配符类型（通配符概念、通配符的超类限定、无限定通配符、通配符捕获）
Zzehao的博客
04-15 901
使用的教材是java核心技术卷1，我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。 day057 泛型类型的继承规则、通配符类型（通配符概念、通配符的超类限定、无限定通配符、通配符捕获） 目录 day057 泛型类型的继承规则、通配符类型（通配符概念、通配符的超类限定、无限定通配符、通配符捕获） 1.泛型类型的继承规则 2.通配符概念 3.通配符的超类型限定 ...
day17 java
11-11
创建一个新的Java工程，可以通过菜单栏的File -> New -> Java Project，然后输入工程名称，比如按照学习进度命名（例如day01）。 **Eclipse使用技巧：** 1. **创建Java工程**：通过File -> New -> Java Project，...
java毕向东源代码16-25天
08-10
【描述】"java毕向东源代码16-25天，共25天" 表明这是一个持续25天的Java学习计划，强调了实践与理论的结合。这期间，学员将通过每一天的学习和编码实践，掌握从第16天到第25天的Java高级特性，如并发编程、集合框架...
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、递归 day09_字节流、字符流...
File练习题
tainxiawuti的博客
08-12 844
利用File构造器，new 一个文件目录file 1)在其中创建多个文件和目录 2)编写方法，实现删除file中指定文件的操作 package test0; import java.io.File; import java.io.IOException; public class ThreadDemo{ public static void main(String[] args...
第10章 流
weixin_33758863的博客
03-26 352
2019独角兽企业重金招聘Python工程师标准>>> ...
Java——使用一个File创建一个目录
Cherry的博客
02-21 3431
package day05; import java.io.File; /** * 使用一个File创建一个目录 * @author Administrator * */ public class FileDemo4 { public static void main(String[] args) { /* * 在当前目录下创建一个目录demo */ File d...
File类
Vv的博客
08-17 352
1、File类的理解 File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)。 File类声明在java.io包下：文件和文件路径的抽象表示形式，与平台无关。 File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 后续Fi
java的file类，创建，遍历，删除
joshuacty的博客
06-01 199
file类是用于访问和操作windows与liunx系统中的文件 1，创建 注意：需要判断文件的上级目录是否存在 2，遍历 需要在判定后递归遍历 3，删除
EduCoder-Java面向对象 -集合框架的实现代码（关卡一到关卡三）包括对问题的总结
小康小白的博客
05-20 3368
我是小康小白，一个平平无奇的Java小白。热爱有趣的文字，生活和远方。 目录： 对实训题目考察的问题的总结 第一关 第一关答案 第二关 第二关答案 第三关 第三关答案 第四关 第四关答案 第五关 第五答案 第六关 第六关答案 对实训题目的总结 这次的实训题目不是很难，主要就是实践了常用集合的用法。其中有一点需要注意。与成员类中的封装属性一样 ArrayList的get方法只能或得对应的值，但不具备输出功能。如果想要输出应当用System.out.println
java------用File类列出一个目录下的所有文件夹和文件
xin053
03-25 1万+
一、预备知识        要知道File类在java.io.File包中，所以要导入这个包。              File类中用到的方法：              boolean isDirectory()       测试此抽象路径名表示的文件是否是个目录              File[] listFiles()           返回一个抽象路径名数组，这些路径名表示
Java泛型
weixin_42556307的博客
06-25 152
一、作用：记住java集合中元素的类型 在不使用泛型时，任何元素被放入集合中，会自动当成Object类型处理，当从程序中取出元素时，往往需要强制类型转换，这种转换不仅会代码臃肿，还容易引起CastClassException异常。 import java.util.List; import java.util.ArrayList; public class Test { public static void main(String[] args) { List str=new ArrayList();
java new File创建文件或目录时的注意事项
热门推荐
qq_2300688967的博客
07-22 9万+
1, 如下代码所示 File dir = new File("root"); File f1 = new File("root"); // 文件对象创建后，指定的文件或目录不一定物理上存在 if(!dir.exists()) { //A ...
java基础(十二 )-----Java泛型详解
最新发布
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值