編程規範總結（一）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; }) }