编程规范总结（一）1014【仅供参考】

常见的数据库中类型和Java类型的对应关系：

JDBC	JAVA
BIGINT	Long
VARCHAR	String
INTEGER	int
SMALLINT	short
BINARY	byte[]
DATA	java.sql.Date
DOUBLE	double
TIMESTAMP	java.sql.Timestamp

Map声明：

map<> map = new HashMap<>(容量);

数据封装 ===》 结构化处理  ===》 分层处理

数据同步job  注意封装  Process==》DataSync==》doDataSync

Map映射

(key，value) put get remove(key)
Rectangle r1 = new Rectangle(0, 0, 5, 5);
look.put("small", r1);
Rectangle r2 = new Rectangle(0, 0, 15, 15);
look.put("medium", r2);
Rectangle r3 = new Rectangle(0, 0, 25, 25);
look.put("large", r3);

Rectangle r = (Rectangle) look.get("medium");
look.remove("large");

//Lambda表达式学习
基本语法：
（参数）-> expression
或者
（参数）-> {statements;}

//简单的Lambda表达式
// 1. 不需要参数,返回值为 5
() -> 5

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

// 以前的循环方式【很重要】                                            ========================》List循环请用Lambda表达式,如果循环体里面的statement简单的话
for (String player : players) {
System.out.print(player + "; ");
}
//Lambda表达:
players.forEach((player) -> System.out.print(player + "; "););

Lambda的学习：

//Person类
public class Person {
private String firstName, lastName, job, gender;
private int salary, age;
public Person(String firstName, String lastName, String job,
String gender, int age, int salary) {
this.firstName = firstName;
this.lastName = lastName;
this.gender = gender;
this.age = age;
this.job = job;
this.salary = salary;
}
// Getter and Setter

List<Person> javaProgrammers = new <Person>() {
{
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
}
};

List<Person> phpProgrammers = new ArrayList<Person>() {
{
add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));
add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
}
}；

javaProgrammers.forEach((p) -> System.out.println("%s %s",p.getFirstName(),p,getLastName()));
phpProgrammers.forEach((p) -> System.out.println("%s %s",p.getFirstName(),p,getLastName()));

//使用过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员
phpProgrammers.stream()
.filter((p) -> (p.getSalary()>1400))
.forEach((p) -> System.out.println("%s %s",p.getFirstName(),p,getLastName()));


//我们也可以定义过滤器,然后重用它们来执行其他操作

Predicate<Person> ageFilter = (p) -> (p.getAge() > 25);
Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400);
Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender()));
//年龄大于24，工资在1400以上的女性php程序员 打印他们的名字
phpProgrammers.stream()
.filter(ageFilter)
.filter(salaryFilter)
.filter(genderFilter)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
javaProgrammers.stream()
.filter(ageFilter)
.filter(genderFilter)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//使用limit方法,可以限制结果集的个数
javaProgrammers.stream()
.limit(3)
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()))；

//在stream中处理排序
List<Person> sortedJavaProgrammers = javaProgrammers.stream()
.sorted((p1,p2) -> p1.getFirstName().compareTo(p2.getFirstName()))
.limit(5)
.collect(toList());
sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
//如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法
Person pers = javaProgrammers
.stream()
.min((p1, p2) -> (p1.getSalary() - p2.getSalary()))
.get();

System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary());

System.out.println("工资最高的 Java programmer:");
Person person = javaProgrammers
.stream()
.max((p, p2) -> (p.getSalary() - p2.getSalary()))
.get();

System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary());

//option学习：

class User
{
String name;
String phone;
Address adderss;
}

class Address{
String province;
String city;
String area;
}

//如果有一个User对象
user.getAddress().getProvince();
//若是user为null，则会抛出NULLPOINTEREXCEPTION（NPE）问题，空指针异常

//当然我们可以进行判断
if(user != null)
{
Address add = user.getAddress();
if(add != null)
{
String pro = add.getProvince();
}
}

// 太笨重了

Optional(T value)构造函数
//Optional的本质，就是内部储存了一个真实的值，在构造的时候，就直接判断其值是否为空
empty()
//返回EMPTY对象
of(T value)
//of(T value)函数内部调用了构造函数
//(1)通过of(T value)函数所构造出的Optional对象，当Value值为空时，依然会报NullPointerException。
//(2)通过of(T value)函数所构造出的Optional对象，当Value值不为空时，能正常构造Optional对象。
ofNullable(T value)
//相比较of(T value)的区别就是，当value值为null时，of(T value)会报NullPointerException异常；ofNullable(T value)不会throw Exception，ofNullable(T value)直接返回一个EMPTY对象

//在构造函数传入的value值为null时，进行调用的,给一个默认值。这两个函数的区别：当user值不为null时，orElse函数依然会执行createUser()方法，而orElseGet函数并不会执行createUser()方法
orElse(T other)
orElseGet(Supplier<? extends T> other)
orElseThrow(Supplier<? extends X> exceptionSupplier)//value值为null时,直接抛一个异常出去

//例如：
User user = null;
user = Optional.ofNullable(user).orElse(createUser());
user = Optional.ofNullable(user).orElseGet(() -> createUser());

取name则：总是忘记optioal还有一个.get()
String city = Optional.ofNullable(user).map(u -> u.getName()).get();

filter(Predicate<? super T> predicate)//满足条件就返回对象，不满足就返回null
//filter 方法接受一个 Predicate 来对 Optional 中包含的值进行过滤，如果包含的值满足条件，那么还是返回这个 Optional；否则返回 Optional.empty
Optional<user> user1 = Optional.ofNullable(user).filter(u -> u.getName().length()<6);

Optional实战
原本写法：
public String getCity(User user) throws Exception{
if(user != null)
{
if(user.getAddress() != null)
{
Address add = user.getAddress();
if(add.getCity() != null){
String pro = add.getCity();
return pro;
}
}
throw new Excpetion("取值错误");
}
}

public String getCity(User user) throws Exception{
return Optional.ofNullable(user)
.filter(u -> u.getAddress())
.filter(p -> p.getCity())
.orElseThrow(() -> new Exception("取值错误"))
}

java8Optional写法：
public String getCity(User user) throws Exception{
return Optional.ofNullable(user)
.map(u -> u.getAddress())
.map(a->a.getCity())
,orElseThrow(()->new Exception("取值错误"));
}
//Optional实战2
原来写：
if(user!=null){
dosomething(user);
}
Optional.ofNullable(user)
.ifPresent(u -> { doingsomething(user)});
java8写：
Optional.ofNullable(user)
.ifPresent(u->{
dosomething(user);
});
//Optional实战3
public User getUser(User user) throws Exception{
if(user!=null){
String name = user.getName();
if("zhangsan".equals(name)){
return user;
}
}else{
user = new User();
user.setName("zhangsan");
return user;
}
}

public User getUser(User user) throws Exception{
return Optional.ofNullable(user)
.fliter(u -> "zhangsan".equals(u.getName()))
.orElseGet(() -> {
user1 = new User();
user1.setName("zhangsan");
return user1;})
}

java8写：Optional.ofNullable()
public User getUser(User user) throws Exception{
Optional.ofNullable(user)
.filter(u -> "zhangsan".equals(u.getName()))
orElseGet(() -> {
User user1 = new User();
user1.setName("zhangsan");
return user1;
})
}