Untitled
unknown
plain_text
a year ago
13 kB
6
Indexable
javacore.organization 1. functionalprogramming 1.1. function 1.1.1. lambda 1.1.1.1. Demo import java.util.ArrayList; import java.util.LinkedList; import java.util.function.Consumer; /* * Bieu thuc Lambda la mot khoi ma nguon, co the co tham so dau vao va tra lai ket qua * Lambda khong can ten va co the cai dat ngay trong phuong thuc */ public class Demo { public static void main(String[] args) { ArrayList<Integer> numbers = new ArrayList<Integer>(); numbers.add(1); numbers.add(3); numbers.add(20); numbers.forEach((n) ->{System.out.print(n + " ");}); System.out.println(); LinkedList<String> stringArr = new LinkedList<String>(); stringArr.add("dog"); stringArr.add("cat"); stringArr.add("rabit"); //khi chi co 1 cau lenh thi co the viet nhu duoi stringArr.forEach(n-> System.out.print(n + " ")); System.out.println(); //hoac viet ngan hon Consumer<Integer> method = System.out::println; numbers.forEach(method); } } ############################### 1.1.1.2. Main.java import java.util.*; public class Main { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.println("Printing from the Runnable"); } }).start(); new Thread(() -> System.out.println("This is a lambda expression")).start(); Employee john = new Employee("John Doe", 30); Employee tim = new Employee("Tim Buchalka", 50); Employee jack = new Employee("Jack Hill", 40); Employee snow = new Employee("Snow White", 25); List<Employee> employees = new ArrayList<>(Arrays.asList(john, tim, jack, snow)); // Collections.sort(employees, new Comparator<Employee>() { // @Override // public int compare(Employee employee1, Employee employee2) { // return employee1.getName().compareTo(employee2.getName()); // } // }); Collections.sort(employees, (employee1, employee2) -> employee1.getName().compareTo(employee2.getName())); // Collections.sort(employees, Comparator.comparing(Employee::getName)); for (Employee employee : employees) { System.out.println(employee.getName() + " - " + employee.getAge()); } String sillyString = doStringStuff((s1, s2) -> s1.toUpperCase() + " - " + s2.toUpperCase(), employees.get(0).getName(), employees.get(1).getName()); System.out.println(sillyString); AnotherClass anotherClass = new AnotherClass(); String s = anotherClass.doSomething(); System.out.println(s); } public final static String doStringStuff(UpperConcat uc, String s1, String s2) { return uc.upperAndConcat(s1, s2); } } class AnotherClass { public String doSomething() { UpperConcat uc = (s1, s2) -> { System.out.println("The lambda expression class's name is: " + getClass().getSimpleName()); String result = s1.toUpperCase() + " - " + s2.toUpperCase(); return result; }; UpperConcat uc1 = new UpperConcat() { @Override public String upperAndConcat(String s1, String s2) { return s1.toUpperCase() + " - " + s2.toUpperCase(); } }; System.out.println("The AnotherClass class's name is: " + getClass().getSimpleName()); return Main.doStringStuff(uc, "String1", "String2"); } } interface UpperConcat { String upperAndConcat(String s1, String s2); } class Employee { private String name; private int age; public Employee(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } class CodeToRun implements Runnable{ @Override public void run() { System.out.println("Printing from Runnable"); } } ############################### 1.1.1.3. Solution.java public class Solution { public interface StringFunction{ String run(String str); } public static void printFormatted(String str, StringFunction format){ String result = format.run(str); System.out.println(result); } public static void main(String[] args) { StringFunction exclaim = (s) -> s + "!!!"; StringFunction as = (s) -> s + "???"; printFormatted("Hello", exclaim); printFormatted("What", as); } } ############################## 1.1.2. methodreference 1.1.2.1. Main.java /* * Method reference cho phep truy cap truc tiep toi cac constructor hoac method cua lop hoac doi tuong * Cu phap: Object :: methodName */ import java.util.Arrays; import java.util.List; import java.util.function.Consumer; public class Main { public static void main(String[] args) { Consumer<String> c = s -> System.out.println(s); Consumer<String> methodReference = System.out::println; List<String> list = Arrays.asList("Thieu", "Hien"); list.forEach(methodReference); MyClass myClass = new MyClass(); list.forEach(myClass::say); list.forEach(Test::say); } } class MyClass { private String str = "Unknown"; public void say(String s) { System.out.println(str + " " + s); } } class Test { private static String str = "Hello"; public static void say(String s) { System.out.println(str + " " + s); } } ####################################### 1.2. functionalstream 1.2.1. stream 1.2.1.1. Main.java /* * input stream: doc data tu source * output stream: ghi data vao dich den * * stream co the chia thanh hai loai dua vao cach chung dai dien cho du lieu: * byte streams: doc va ghi du lieu theo byte -> co the hoat dong voi bat ky data loai nao (ke ca multimedia) * char streams: doc va ghi du lieu duoi dang ki tu theo dinh dang Unicode 16 bit * * mot vai stream su dung vi tri bo nho tam thoi (temporary memory location) -> thuong la mot mang byte hoac char * duoc goi la buffer * buffer cho phep doc luong lon du lieu tu data source va luu vao bo nho tam -> giam so lan truy cap vao data source * (Giam so lan hoat dong I/O) */ public class Main { public static void main(String[] args) { MyClass myClass = new MyClass(); MyClass.method2(); } } class MyClass { static int field = 10; public MyClass() { method3(); // (1) } void method1() { method2(); // (2) } static void method2() { MyClass myClass = new MyClass(); myClass.method3(); // (3) } void method3() { System.out.println(field); // (4) } } ############################################### 2. genericprogramming 2.1. essentials 2.2. internals 2.3. old 2.3.1. BaseballPlayer public class BaseballPlayer extends Player{ public BaseballPlayer(String name) { super(name); } } ############################################### 2.3.2.FootballPlayer public class FootballPlayer extends Player{ public FootballPlayer(String name) { super(name); } } ################################################ 2.3.3. Generics import java.util.ArrayList; import java.util.Arrays; public class Generics { public static void main(String[] args) { // genericsIntroduce(); myGenerics(); } public static void myGenerics() { FootballPlayer joe = new FootballPlayer("Joe"); BaseballPlayer pat = new BaseballPlayer("Pat"); SoccerPlayer beckham = new SoccerPlayer("Beckham"); Team<FootballPlayer> adelaideCrows = new Team<>("Adelaide Crows"); adelaideCrows.addPlayer(joe); System.out.println(adelaideCrows.numPlayers()); Team<BaseballPlayer> baseballTeam = new Team<>("Chicago Cubs"); baseballTeam.addPlayer(pat); Team<SoccerPlayer> brokenTeam = new Team<>("This won't work"); brokenTeam.addPlayer(beckham); Team<FootballPlayer> melbourne = new Team<>("Melbourne"); FootballPlayer banks = new FootballPlayer("Gordon"); melbourne.addPlayer(banks); Team<FootballPlayer> hawthorn = new Team<>("Hawthorn"); Team<FootballPlayer> fremantle = new Team<>("Fremantle"); hawthorn.matchResult(fremantle, 1, 0); hawthorn.matchResult(adelaideCrows, 3, 8); adelaideCrows.matchResult(fremantle, 2, 1); System.out.println("Ranking"); System.out.println(adelaideCrows.getName() + ": " + adelaideCrows.ranking()); System.out.println(melbourne.getName() + ": " + melbourne.ranking()); System.out.println(fremantle.getName() + ": " + fremantle.ranking()); System.out.println(hawthorn.getName() + ": " + hawthorn.ranking()); System.out.println(adelaideCrows.compareTo(melbourne)); System.out.println(adelaideCrows.compareTo(hawthorn)); System.out.println(hawthorn.compareTo(adelaideCrows)); System.out.println(melbourne.compareTo(fremantle)); } public static void genericsIntroduce() { // raw type ArrayList items = new ArrayList(); items.add(1); items.add(2); items.add(3); items.add(4); items.add(5); items.add(2.5); // generic ArrayList<Integer> newItems = new ArrayList<>(Arrays.asList(6, 7, 8, 9, 10)); printDoubled(newItems); } private static void printDoubled(ArrayList<Integer> arr) { for (Integer i : arr) { System.out.println(i * 2); } } } #################################################### 2.3.4. Player public abstract class Player { private String name; public Player(String name) { this.name = name; } public String getName() { return name; } } ############################################### 2.3.5. SoccerPlayer public class SoccerPlayer extends Player{ public SoccerPlayer(String name) { super(name); } } ########################################### 2.3.6. Team public class Team<T extends Player> implements Comparable<Team<T>>{ private String name; int played = 0; int won = 0; int lose = 0; int tied = 0; private ArrayList<T> members = new ArrayList<>(); public Team(String name) { this.name = name; } public String getName() { return name; } public boolean addPlayer(T player) { if (members.contains(player)) { System.out.println(player.getName() + " is already on this team."); return false; } else { members.add(player); System.out.println(player.getName() + " picked for team " + this.name); return true; } } public int numPlayers() { return this.members.size(); } public void matchResult(Team<T> opponent, int outScore, int theirScore) { String message; if (outScore > theirScore) { won++; message = " beat "; } else if (outScore == theirScore) { tied++; message = " drew with "; } else { lose++; message = " lost to "; } played++; if (opponent != null) { System.out.println(this.getName() + message + opponent.getName()); opponent.matchResult(null, theirScore, outScore); } } public int ranking() { return (won * 2) + tied; } @Override public int compareTo(Team<T> o) { return Integer.compare(this.ranking(), o.ranking()); } } ########################################### 3. method 3.1. Overloading public class Overloading { static void myMethod(String iName){ // static -> phuong thuc nay thuoc Main va khong phai mot doi tuong cua Main System.out.println("Hello "+ iName); } //Method Overloading static int plusMethod(int x, int y){ return x + y; } static double plusMethod(double x, double y){ return x + y; } public static void main(String[] args) { myMethod("Thieu"); System.out.println(plusMethod(2,1)); System.out.println(plusMethod(2.1, 1.8)); Overloading.myMethod("Han"); } }
Editor is loading...
Leave a Comment