JAVA学习历程记录（六）

JAVA学习历程记录（六）

Stream流式结构

提供了大量的批量操作集合数据的方法

package old;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("1ad");
        list.add("2asd");
        list.add("2sd");
        list.add("2da");
        //获取流式结构
        Stream<String> stream = list.stream();
       //使用匿名类方法
//        stream.filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("3");
//            }
//        }).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
         //使用lamada
        stream.filter(str -> str.startsWith("2")).
        //变成大写
//      map(str -> str.toUpperCase()).       
        sorted((s1,s2) -> s1.compareTo(s2)).
        forEach(str -> System.out.println(str));
    
    }
}

泛型

保证程序的安全性，减少了代码量，避免了类型的强制转换
泛型可以应用在接口，类，方法上

T	type
E	element
R	result
K	key
V	value

泛型方法

在返回值类型前面加上<大写字母>,在调用方法时才去做泛型擦除

泛型的上限和下限

泛型的上限：extends xxxx 泛型应该是xxxx自身或它的子类或者子接口
泛型的下限：super xxxx 泛型应该是xxxx的自身或者它的父类或者父接口

练习

package old;

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

public class Fan {
    public static void main(String[] args) {
        Person<String,Integer> person = new Person<>();
        person.setName("张三");
        person.setAge(15);
        System.out.println(person.getAge());
        System.out.println(person.getName());
        Myinterimpl ml = new Myinterimpl();
        Myinterimpl1 ml1 = new Myinterimpl1();
        ml.inter();
        ml1.inter();
        List<String> list = new ArrayList<>();
        m(list);
        List<Double> list1 = new ArrayList<>();

    }
    public static void m(List<? super String> list){
        
    }
    public static void c(List<? extends Float> list){
        
    }

}
interface MyInter<O>{
    void inter();
}
class Myinterimpl1 implements MyInter<String>{
    private String name1;
    private String age1;

    @Override
    public void inter() {
        System.out.println("接口1");
    }
}
class Myinterimpl<O> implements MyInter<O>{
    private O name;
    private O age;

    @Override
    public void inter() {
        System.out.println("接口");
    }
}




class Person<S,I>{
    private S name;
    private I age;

    public S getName() {
        return name;
    }

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

    public I getAge() {
        return age;
    }

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

Map

1.Map是由键值对组成的容器，里面的元素由键和值两部分组成，通过键可以找到对应的值
2.Map中的键是key，值是value，Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值，key-value称之为键值对。
3.将每个键值对看作一个对象，抽取出一个代表键值对的接口——Map.Enty。一个映射是由多个Entry对象组成。

常用API

//创建对象
Map<String,Integer> map = new HashMap<>();

//添加数据，可以存放null
map.put("asd",1);

//清除映射
map.clear;

//是否包含某一个key
map.containsKey("asd");
//是否包含某一个value
map.containsValue(1);

//获取映射的键值对集合
Set<Map.Entry<Integer,String>> set = map.entrySet();
System.out.println(set);

//通过key获取value
map.get(key);

//判断是否是空
map.isEmpty();

//获得所有key的合集
Set<String> set = map.keySet();
System.out.println(set);

//根据key删除value
Integer in = map.remove("asd");

//键值对的对数
map.size();

//获取映射中所有的值
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);

遍历Map

Set<Integer> set = map.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
    Integer in = it.next();
    String str =map.get(in);
}

Set<Map.Entry<Integer,String>> set = map.entrySet();
Iterator<Map.Entry<Integer,String>> iterator = set.iterator();
while (iterator.hasNext()){
    Map.Entry<Integer,String> en = iterator.next();
    Integer in = en.getKey();
    String str = en.getValue();
}

for (Map.Entry<Integer,String> en : map.entrySet()){
    System.out.println(en.getKey()+en.getValue());
}

练习
输入一个字符串，统计字符出现的次数

package old;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class MapPratice {
    public static void main(String[] args) {
        String str = new Scanner(System.in).next();
        Map<Character,Integer> map = new HashMap<>();
        for (int i = 0;i < str.length() ;i++){
            char a = str.charAt(i);
            if (map.containsKey(a)){
                int c = map.get(a);
                c++;
                map.put(a,c);
            }
            else map.put(a,1);
        }
        System.out.println(map);
    }}

HashMap

默认初始容量是16，加载因子为0.75
HashMap允许键值为null
HashMap的容量一定是2的n次方的形式
HashMap是异步线程不安全的

Hasgtable

不允许键和值为null
默认初始容量是11，加载因子是0.75
默认扩容是先扩大一倍再加1
可以指定容量
同步式线程安全的映射

File

常用API

//创建对象
//将对象和路径进行了关联
File file = new File("Path");

//创建目录
file.createNewFile();

//创建目录
file.mkdir();
file.mkdirs();

//判断是否是文件
file.isFile;

//判断是否是目录
file.isDirectory;

//删除文件
file.delete();

//判断文件是否可写
file.canWrite();

//判断文件是否存在
file.exists();

//获得绝对路径
file.getAbsolutePath();

//剩余空间
file.getFreeSpace();

//获得总空间
file.getTotalSpace();

//可用空间
file.getUsableSpace();

//设置修改时间
file.setLastModified(123L);

//获取修改时间
file.lastModified();

//移动并修改名称
file.renameTo(new File("Path"));

练习
删除一个目录中所有内容

public class FilePratice {
    public static void main(String[] args) {
        File file = new File("E:\\123");
        del(file);
    }
    public static void del(File file){
        if (file.isDirectory()){
        File[] files = file.listFiles();
        for (File f : files){
            del(f);
        }
    }file.delete();}
}

统计工作空间中所有的.java和.class文件

static int classcount;
static int javacount;
public static void main(String[] args) {
    File file = new File("E:\\idea");
    count(file);
    System.out.println(javacount);
    System.out.println(classcount);
}
public static void count(File file) {
    if (file.isDirectory()) {
        File[] files = file.listFiles();
        for (File f : files) {
            count(f);
        }}

     else if (file.getName().endsWith(".java")) {
                classcount++;
      } 
     else if (file.getName().endsWith(".class")) {
                javacount++;
            }

    }