java成神之——properties,lambda表达式,序列化

Properties
Lambda表达式
序列化
Comparable和Comparator
- Comparable对象排序
- Comparator对象排序
结语

Properties

加载defaults.properties文件

defaults.properties内容如下

    lastname=Smith

获取properties属性（defaults.properties文件和TestController文件置于同级目录）

    try (InputStream bundledResource = TestController.class.getResourceAsStream("defaults.properties")) {

        Properties defaults = new Properties();

        defaults.load(bundledResource);

        return defaults;

    } catch (IOException e) {

        throw new UncheckedIOException( "defaults.properties not properly packaged" + " with application", e);

    }

写Properties到xml文件

Properties prop = new Properties();

prop.setProperty("name", "Steve");

prop.setProperty("color", "green");

prop.setProperty("age", "23");

File file = new File("C:\\Users\\26401\\Desktop\\defaults.properties");

if (!file.exists()){

    file.createNewFile();

}

prop.storeToXML(new FileOutputStream(file), "testing properties with xml");

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">

<properties>

<comment>testing properties with xml</comment>

<entry key="color">green</entry>

<entry key="name">Steve</entry>

<entry key="age">23</entry>

</properties>

读Properties从xml文件

Properties prop = new Properties();

File file = new File("C:\\Users\\26401\\Desktop\\defaults.properties");

if (file.exists()){

    prop.loadFromXML(new FileInputStream(file));

    for (String name : prop.stringPropertyNames()){

        System.out.println(name + "=" + prop.getProperty(name));

    }

}else {

    System.err.println("Error: No file found at: " + file);

}

Lambda表达式

自定义

Lambda表达式只能用于函数式接口

函数式接口只能包含一个抽象方法，可以有多个default和static方法，可以有多个重写对象的方法

@FunctionalInterface

interface MyFunctionalInterface {

    void fn();

}

MyFunctionalInterface mfi = () -> System.out.println("函数式接口");

mfi.fn();

等价于

MyFunctionalInterface mfi = new MyFunctionalInterface() {

    @Override

    public void fn() {

        System.out.println("函数式接口");

    }

};

内置

Predicate<String> p = o -> o.isEmpty();            // 返回值类型必须是布尔值

Function<String, Boolean> f = o -> o.isEmpty();    // 返回值类型可以自定义

Consumer<String> c = o -> System.out.println(o);   // 返回值类型为void

c.accept("没有返回值");

sort方法中使用Lambada

原始写法

List<Integer> list = new ArrayList<>();

list.add(3);

list.add(1);

list.add(2);

Collections.sort(list, new Comparator<Integer>(){

    public int compare(Integer b, Integer l){

        return b.compareTo(l);

    }

}); // [1,2,3]

Lambada写法

Collections.sort(list, (b, l) -> b.compareTo(l));

或者

Collections.sort(list, Comparator.comparing(Integer::valueOf));

序列化

文件序列化

public class SerialClass implements Serializable {

    private static final long serialVersionUID = 1L;

}

Gson序列化

<dependency>

    <groupId>com.google.code.gson</groupId>

    <artifactId>gson</artifactId>

    <version>2.8.5</version>

</dependency>

public class User {

    private Integer id;

    private String name;

    public User(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    getter...

    setter...

}

// 序列化成json

User user = new User(1, "小李");

Gson gson = new Gson();

String json = gson.toJson(user);

// 反序列化

User userCopy = gson.fromJson(json, User.class);

Jackson序列化

依赖

    <dependency>

        <groupId>com.fasterxml.jackson.core</groupId>

        <artifactId>jackson-databind</artifactId>

        <version>2.9.6</version>

    </dependency>

json字符串转对象

    ObjectMapper objectMapper = new ObjectMapper();

    User outputObject = objectMapper.readValue( "{\"id\":\"1\",\"name\":\"小叶\"}", User.class);

    outputObject.getName();

    @JsonIgnoreProperties(ignoreUnknown = true) // 忽视反序列化遇到的不认识的属性

    public class User {

        ...

    }

对象转字符串

    User user = new User(1, "小李");

    ObjectMapper objectMapper = new ObjectMapper();

    String json = objectMapper.writeValueAsString(user);

Comparable和Comparator

Comparable对象排序

public class User implements Comparable<User> {

    private Integer id;

    private String name;

    public User(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public Integer getId() {

        return id;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getName() {

        return name;

    }

    @Override

    public boolean equals(Object o) {

        if (! (o instanceof User)) return false;

        User p = (User)o;

        return id.equals(p.id) && name.equals(p.name);

    }

    @Override

    public int hashCode() {

        return Objects.hash(id, name);

    }

    @Override

    public int compareTo(User other) {

        int idCompare = id.compareTo(other.id);

        if (idCompare != 0) {

            return idCompare;

        } else {

            return id.compareTo(other.id);

        }

    }

}

List<User> list = Arrays.asList(new User(2, "小李"), new User(3, "小李"), new User(1, "小李"));

Collections.sort(list);

Comparator对象排序

List<User> list = Arrays.asList(new User(2, "小李"), new User(3, "小张"), new User(1, "小王"));

Collections.sort(list, new Comparator<User>() {

    @Override

    public int compare(User u1, User u2) {

        return u1.getId().compareTo(u2.getId());

    }

});

Collections.sort(list,(u1, u2) -> {

    return u1.getId().compareTo(u2.getId());

});

Collections.sort(list,Comparator.comparing(User::getId).thenComparing(User::getName));

结语

本文章是java成神的系列文章之一

如果你想知道，但是本文没有的，请下方留言

我会第一时间总结出来并发布填充到本文

巴特西

java成神之——properties,lambda表达式,序列化

Properties

加载defaults.properties文件

写Properties到xml文件

读Properties从xml文件

Lambda表达式

自定义

内置

sort方法中使用Lambada

序列化

文件序列化

Gson序列化

Jackson序列化

Comparable和Comparator

Comparable对象排序

Comparator对象排序

结语

最新文章

热门文章