Untitled
unknown
plain_text
a year ago
33 kB
13
Indexable
javacore.data
1. array
1.1. Array.java
import java.util.Arrays;
import java.util.Scanner;
public class Array {
private static int[] baseData = new int[10];
public static void main(String[] args) {
// myArray();
sum();
getInput();
resizeArray();
baseData[10] = 100;
baseData[11] = 22;
printArray(baseData);
String[] array = {"b", "a", "g", "d"};
java.util.Arrays.sort(array);
Arrays.stream(array)
.forEach(System.out::println);
}
public static void resizeArray() {
int[] original = baseData;
baseData = new int[12];
for (int i = 0; i < original.length; i++) {
baseData[i] = original[i];
}
}
public static void getInput() {
for (int i = 0; i < baseData.length; i++) {
baseData[i] = i * 10;
}
}
public static void myArray() {
int[] myIntArray = new int[10];
myIntArray[5] = 50;
int[] myNumbers = {1, 2, 3, 4, 5};
printArray(myNumbers);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println("Element " + i + ": " + arr[i]);
}
}
public static void sum() {
Scanner scanner = new Scanner(System.in);
int length = scanner.nextInt();
int[] arr = new int[length];
for (int i = 0; i < length; i++) {
arr[i] = scanner.nextInt();
}
int n = scanner.nextInt();
int sum = 0;
for (int num : arr) {
if (num > n) {
sum += num;
}
}
System.out.println(sum);
}
}
####################################
1.2. MultidimensionalArray.jva
import java.util.Arrays;
import java.util.Scanner;
public class MultidimensionalArray {
public static void main(String[] args) {
exercise3();
}
public static void exercise1() {
Scanner scanner = new Scanner(System.in);
int row = scanner.nextInt();
int col = scanner.nextInt();
int[][] arr = new int[row][col];
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
arr[i][j] = scanner.nextInt();
}
}
int c1 = scanner.nextInt();
int c2 = scanner.nextInt();
int temp = 0;
if (c1 > c2) {
temp = c1;
c1 = c2;
c2 = temp;
}
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if (j == c1) {
temp = arr[i][c1];
arr[i][c1] = arr[i][c2];
arr[i][c2] = temp;
}
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
public static void exercise2() {
int[][] arrays = {{1, 2}, {0, 0}, {3, 4}};
printCorners(arrays);
}
public static void printCorners(int[][] twoDimArray) {
// write your code here
System.out.print(twoDimArray[0][0] + " ");
System.out.println(twoDimArray[0][twoDimArray[0].length - 1]);
System.out.print(twoDimArray[twoDimArray.length - 1][0] + " ");
System.out.println(twoDimArray[twoDimArray.length - 1][twoDimArray[twoDimArray.length - 1].length - 1]);
}
public static void exercise3() {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[][] arrays = new int[n][n];
int[][] transposedArrays = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
arrays[i][j] = scanner.nextInt();
transposedArrays[j][i] = arrays[i][j];
}
}
System.out.println(Arrays.equals(arrays, transposedArrays)); // false
boolean check = Arrays.deepEquals(arrays, transposedArrays); // true
System.out.println(check? "YES" : "NO");
}
}
##############################################
1.3. Solution.java
public class Solution {
public static void main(String[] args) {
String[] cars = { "Volvo", "BMW", "Ford", "Mazda" };
cars[0] = "Opel";
System.out.println(cars[0]);
for (int i = 0; i < cars.length; i++) {
System.out.println(cars[i]);
}
int[] mNum = { 10, 20, 30, 40 };;
System.out.println(mNum.length);
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
System.out.println(myNumbers[1][2]);
int[] num = new int[4];
}
}
###############################################
1.4. Varargs.java
/*
* Passing arrays to methods
* Mot method co the co tham so la mot array
* Khi truyen mot gia tri kieu nguyen thuy vao method, mot ban sao cua gia tri se duoc tao
* Khi truyen mot mang, mot ban sao reference se duoc tao, tuc la khi thay doi mang o trong method thi khi thoat khoi
* method do, mang van se thay doi
*
* Varargs (variable-length arguments)
* Vi du: int... number
* co the xu ly tham so loai nay nhu mot mang thong thuong
*/
import java.util.Arrays;
public class Varargs {
public static void main(String[] args) {
int[] number = {1, 2, 3, 4, 5};
swapFirstAndLastElements(number);
System.out.println(Arrays.toString(number));
printNumberOfArguments(1);
printNumberOfArguments(1, 2, 3);
printNumberOfArguments();
printNumberOfArguments(new int[] {1, 2});
}
public static void inverseFlags(boolean[] flags) {
// write your code here
for (int i = 0; i < flags.length; i++) {
flags[i] = !flags[i];
}
}
public static void swapFirstAndLastElements(int[] nums) { // nums is an array
if (nums.length < 1) {
return; // it returns nothing, i.e. just exits the method
}
int temp = nums[nums.length - 1]; // save the last element in a temporary local variable
nums[nums.length - 1] = nums[0]; // now, the last element becomes the first
nums[0] = temp; // now, the first element becomes the former last
}
public static void printNumberOfArguments(int... numbers) {
System.out.println(numbers.length);
}
}
#########################################
2. collections
2.1. queue
2.2. deque
2.3. example
2.3.1. example1
2.3.1.1. CollectionListMethod.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionListMethod {
public static void main(String[] args) {
Theatre theatre = new Theatre("Olympian", 8, 12);
List<Theatre.Seat> seatCopy = new ArrayList<>(theatre.seats); // Shallow copy
printList(seatCopy);
Collections.reverse(seatCopy);
Collections.shuffle(seatCopy);
printList(seatCopy);
printList(theatre.seats);
Theatre.Seat minSeat = Collections.min(seatCopy);
Theatre.Seat maxSeat = Collections.max(seatCopy);
System.out.println("Min seat number is " + minSeat.getSeatNumber());
System.out.println("Max seat number is " + maxSeat.getSeatNumber());
System.out.println("=========================================================================================");
sortList(seatCopy);
printList(seatCopy);
}
public static void printList(List<Theatre.Seat> list) {
for(Theatre.Seat seat : list) {
System.out.print(" " + seat.getSeatNumber());
}
System.out.println();
System.out.println("=========================================================================================");
}
public static void sortList(List<? extends Theatre.Seat> list) {
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i).compareTo(list.get(j)) > 0) {
Collections.swap(list, i, j);
}
}
}
}
}
##################################
2.3.1.2. Main.java
/*
* Collection (Interface) bao gom: List, Set, Queue, Deque, Map
* Chu y: Map khong truc tiep trien khai giao dien Collection
*/
public class Main {
public static void main(String[] args) {
Theatre theatre = new Theatre("Olympian", 8, 12);
theatre.getSeats();
theatre.reserveSeat("H11");
// List<String> list = new ArrayList<>(Arrays.asList("Abc", "xyz"));
// System.out.println(list);
// list = new LinkedList<>();
}
}
###################################
2.3.1.3. Theatre.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Theatre {
private final String theatreName;
public List<Seat> seats = new ArrayList<>();
public Theatre(String theatreName, int numRows, int seatsPerRow) {
this.theatreName = theatreName;
int lastRow = 'A' + (numRows - 1);
for (char row = 'A'; row <= lastRow; row++) {
for (int seatNum = 1; seatNum <= seatsPerRow; seatNum++) {
Seat seat = new Seat(row + String.format("%02d", seatNum));
seats.add(seat);
}
}
}
public String getTheatreName() {
return theatreName;
}
public boolean reserveSeat(String seatNumber) {
Seat requestedSeat = new Seat(seatNumber);
int foundSeat = Collections.binarySearch(seats, requestedSeat, null);
if (foundSeat >= 0) {
return seats.get(foundSeat).reserve();
} else {
System.out.println("There is no seat " + seatNumber);
return false;
}
}
// for testing
public void getSeats() {
for (Seat seat : seats) {
System.out.println(seat.getSeatNumber());
}
}
public class Seat implements Comparable<Seat> {
private final String seatNumber;
private boolean reserved = false;
private Seat(String seatNumber) {
this.seatNumber = seatNumber;
}
public String getSeatNumber() {
return seatNumber;
}
public boolean reserve() {
if (!this.reserved) {
this.reserved = true;
System.out.println("Seat " + seatNumber + " reserved");
return true;
} else {
return false;
}
}
public boolean cancel() {
if (this.reserved) {
this.reserved = false;
System.out.println("Reservation of seat " + seatNumber + " cancelled");
return true;
} else {
return false;
}
}
@Override
public int compareTo(Seat seat) {
return this.seatNumber.compareToIgnoreCase(seat.getSeatNumber());
}
}
}
##########################################
2.3.2. example2
2.3.2.1. ComparatorAndComparable
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ComparatorAndComparable {
public static void main(String[] args) {
Theatre theatre = new Theatre("Olympian", 8, 12);
if (theatre.reserveSeat("D12")) {
System.out.println("Please pay for D12");
} else {
System.out.println("Seat already reserved");
}
if (theatre.reserveSeat("B13")) {
System.out.println("Please pay for B13");
} else {
System.out.println("Seat already reserved");
}
List<Theatre.Seat> reservedSeats = new ArrayList<>(theatre.getSeats());
Collections.reverse(reservedSeats);
printList(reservedSeats);
List<Theatre.Seat> priceSeats = new ArrayList<>(theatre.getSeats());
priceSeats.add(theatre.new Seat("B00", 13.00));
priceSeats.add(theatre.new Seat("A00", 13.00));
Collections.sort(priceSeats, Theatre.PRICE_ORDER);
printList(priceSeats);
}
public static void printList(List<Theatre.Seat> list) {
for(Theatre.Seat seat : list) {
System.out.print(" " + seat.getSeatNumber() + " " + seat.getPrice());
}
System.out.println();
System.out.println("=========================================================================================");
}
}
#######################################
2.3.2.2. Theatre.java
import java.util.*;
public class Theatre {
private final String theatreName;
private List<Seat> seats = new ArrayList<>();
static final Comparator<Seat> PRICE_ORDER = new Comparator<Seat>() {
@Override
public int compare(Seat seat1, Seat seat2) {
if (seat1.getPrice() < seat2.getPrice()) {
return -1;
} else if (seat1.getPrice() > seat2.getPrice()) {
return 1;
} else {
return 0;
}
}
};
public Theatre(String theatreName, int numRows, int seatsPerRow) {
this.theatreName = theatreName;
int lastRow = 'A' + (numRows - 1);
for (char row = 'A'; row <= lastRow; row++) {
for (int seatNum = 1; seatNum <= seatsPerRow; seatNum++) {
double price = 12.00;
if ((row < 'D') && (seatNum >= 4 && seatNum <= 9)) {
price = 14.00;
} else if ((row > 'F') || (seatNum < 4) || seatNum > 9) {
price = 7.00;
}
Seat seat = new Seat(row + String.format("%02d", seatNum), price);
seats.add(seat);
}
}
}
public String getTheatreName() {
return theatreName;
}
public boolean reserveSeat(String seatNumber) {
Seat requestedSeat = new Seat(seatNumber);
int foundSeat = Collections.binarySearch(seats, requestedSeat, null);
if (foundSeat >= 0) {
return seats.get(foundSeat).reserve();
} else {
System.out.println("There is no seat " + seatNumber);
return false;
}
}
// for testing
public Collection<Seat> getSeats() {
return seats;
}
public class Seat implements Comparable<Seat> {
private final String seatNumber;
private double price;
private boolean reserved = false;
private Seat(String seatNumber) {
this.seatNumber = seatNumber;
}
Seat(String seatNumber, double price) {
this.seatNumber = seatNumber;
this.price = price;
}
public String getSeatNumber() {
return seatNumber;
}
public double getPrice() {
return price;
}
public boolean reserve() {
if (!this.reserved) {
this.reserved = true;
System.out.println("Seat " + seatNumber + " reserved");
return true;
} else {
return false;
}
}
public boolean cancel() {
if (this.reserved) {
this.reserved = false;
System.out.println("Reservation of seat " + seatNumber + " cancelled");
return true;
} else {
return false;
}
}
@Override
public int compareTo(Seat seat) {
return this.seatNumber.compareToIgnoreCase(seat.getSeatNumber());
}
}
}
#############################################
2.4. list
2.4.1. arraylist
2.4.1.1. GroceryList.java
import java.util.ArrayList;
public class GroceryList {
private static ArrayList<String> groceryList = new ArrayList<>();
public ArrayList<String> getGroceryList() {
return groceryList;
}
public void addGroceryItem(String item) {
groceryList.add(item);
}
public void printGroceryList() {
System.out.println("You have " + groceryList.size() + " items in your grocery list.");
for (int i = 0; i < groceryList.size(); i++) {
System.out.println((i + 1) + ". " + groceryList.get(i));
}
}
public void modifyGroceryItem(String currentItem, String newItem) {
int position = findItem(currentItem);
if (position >= 0) {
modifyGroceryItem(position, newItem);
}
}
private void modifyGroceryItem(int position, String newItem) {
groceryList.set(position, newItem);
System.out.println("Grocery item " + (position + 1) + " has been modified.");
}
public void removeGroceryItem(String item) {
int position = findItem(item);
if (position >= 0) {
removeGroceryItem(position);
}
}
private void removeGroceryItem(int position) {
String theItem = groceryList.get(position);
groceryList.remove(position);
System.out.println("Grocery item " + theItem + " has been removed.");
}
private int findItem(String searchItem) {
return groceryList.indexOf(searchItem);
}
public boolean onFile(String searchItem) {
int position = findItem(searchItem);
return position >= 0;
}
}
#################################################
2.4.1.2. Main.java
import java.util.*;
/*
*
*/
public class Main {
private static Scanner scanner = new Scanner(System.in);
private static GroceryList groceryList = new GroceryList();
public static void main(String[] args) {
//testArrayList();
myIterator();
// groceryListExercise();
}
public static void groceryListExercise() {
boolean quit = false;
int choice = 0;
printInstructions();
while (!quit) {
System.out.println("Enter your choice: ");
choice = scanner.nextInt();
scanner.nextLine();
switch (choice) {
case 0 -> printInstructions();
case 1 -> groceryList.printGroceryList();
case 2 -> addItem();
case 3 -> modifyItem();
case 4 -> removeItem();
case 5 -> searchForItem();
case 6 -> processArrayList();
case 7 -> quit = true;
default -> {}
}
}
}
private static void processArrayList() {
ArrayList<String> newArray = new ArrayList<>();
newArray.addAll(groceryList.getGroceryList());
// Cach khac
ArrayList<String> nextArray = new ArrayList<>(groceryList.getGroceryList());
String[] myArray = new String[groceryList.getGroceryList().size()];
groceryList.getGroceryList().toArray(myArray);
}
private static void searchForItem() {
System.out.print("Item to search for: ");
String searchItem = scanner.nextLine();
if (groceryList.onFile(searchItem)) {
System.out.println("Found " + searchItem + " in our grocery list.");
} else {
System.out.println(searchItem + " is not in the shopping list.");
}
}
private static void removeItem() {
System.out.print("Enter item number: ");
String removeItem = scanner.nextLine();
scanner.nextLine();
groceryList.removeGroceryItem(removeItem);
}
private static void modifyItem() {
System.out.print("Enter item number: ");
String curItem = scanner.nextLine();
scanner.nextLine();
System.out.print("Enter replacement item: ");
String newItem = scanner.nextLine();
groceryList.modifyGroceryItem(curItem, newItem);
}
private static void addItem() {
System.out.print("Please enter the grocery item: ");
groceryList.addGroceryItem(scanner.nextLine());
}
private static void printInstructions() {
System.out.print("\nPress ");
System.out.print("\n 0 - To print choice options.");
System.out.print("\n 1 - To print the list of grocery item.");
System.out.print("\n 2 - To add an item to the list.");
System.out.print("\n 3 - To modify an item in the list.");
System.out.print("\n 4 - To remove an item from the list.");
System.out.print("\n 5 - To search for an item in the list.");
System.out.print("\n 6 - .");
System.out.print("\n 7 - To quit the application.\n");
}
public static void testArrayList() {
ArrayList<String> cars = new ArrayList<>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
System.out.println(cars.get(2));
cars.set(2, "Opel");
System.out.println(cars);
cars.remove(0);
System.out.println(cars);
System.out.println(cars.size());
Collections.sort(cars);
System.out.println(cars);
ArrayList<Object> arr = new ArrayList<>();
arr.add(1);
arr.add("Thieu");
arr.add(2.5);
for (Object o : arr) {
System.out.println(o);
}
ArrayList<String> names = new ArrayList<>(Arrays.asList("Thieu", "Hien", "Tung"));
}
public static void myIterator() {
ArrayList<String> stringList = new ArrayList<>();
stringList.add("A");
stringList.add("B");
stringList.add("C");
stringList.add("D");
stringList.add("E");
Iterator<String> iterator = stringList.iterator();
while ((iterator.hasNext())) {
String letter = iterator.next();
if (letter.equals("C")) {
iterator.remove();
}
}
for (String s : stringList) {
System.out.println(s);
}
}
}
###############################################
2.4.2. linkedlist
2.4.2.1. Customer.java
public class Customer {
private String name;
private double balance;
public Customer(String name, double balance) {
this.name = name;
this.balance = balance;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
#########################################
2.4.2.2. Demo.java
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;
/*
* Iterator va ListIterator deu co cach hoat dong va ham tuong tu nhau, nhung co nhung diem khac nhau:
* - Iterator dung de duyet qua cac phan tu cua Collection, con ListIterator chi dung de duyet qua List
* - Iterator chi co the duyet theo mot huong, con ListIterator co the duyet theo ca hai chieu, vi the no cung cap
* cac phuong thuc: hasPrevious(), previous(). Ngoai ra ListIterator con co phuong thuc set() de dat lai gia tri cua
* mot phan tu va phuong thuc add() de them phan tu.
*/
public class Demo {
public static void main(String[] args) {
test3();
}
public static void test1() {
LinkedList<String> placesToVisit = new LinkedList<>();
placesToVisit.add("Thai Binh");
placesToVisit.add("Ha Noi");
placesToVisit.add("Hai Phong");
placesToVisit.add("Nam Dinh");
placesToVisit.add("Hung Yen");
placesToVisit.add("Ha Nam");
printList(placesToVisit);
placesToVisit.add(1, "Ninh Binh");
printList(placesToVisit);
placesToVisit.remove(4);
printList(placesToVisit);
placesToVisit.remove("Bac Ninh");
}
public static void test2() {
LinkedList<String> placesToVisit = new LinkedList<>();
placesToVisit.add("Thai Binh");
placesToVisit.add("Ha Noi");
placesToVisit.add("Hai Phong");
placesToVisit.add("Nam Dinh");
placesToVisit.add("Hung Yen");
placesToVisit.add("Ha Nam");
ListIterator<String> stringListIterator = placesToVisit.listIterator();
while (stringListIterator.hasNext()) {
String city = stringListIterator.next();
if (city.equals("Hung Yen")) {
stringListIterator.set("Bac Ninh");
stringListIterator.add("Bac Giang");
}
}
printList(placesToVisit);
}
public static void test3() {
LinkedList<String> placesToVisit = new LinkedList<>();
addInOrder(placesToVisit, "Thai Binh");
addInOrder(placesToVisit, "Ha Noi");
addInOrder(placesToVisit, "Phu Tho");
addInOrder(placesToVisit, "Thai Nguyen");
addInOrder(placesToVisit, "Ha Giang");
addInOrder(placesToVisit, "Lai Chau");
addInOrder(placesToVisit, "Son La");
printList(placesToVisit);
visit(placesToVisit);
}
private static void printList(LinkedList<String> linkedList) {
Iterator<String> i = linkedList.iterator();
while (i.hasNext()) {
System.out.println("Now visiting " + i.next());
}
System.out.println("===========================");
}
private static boolean addInOrder(LinkedList<String> linkedList, String newCity) {
ListIterator<String> stringListIterator = linkedList.listIterator();
while (stringListIterator.hasNext()) {
int comparison = stringListIterator.next().compareTo(newCity);
if (comparison == 0) {
// equal
System.out.println(newCity + " is already included as a destination");
return false;
} else if (comparison > 0) {
// new city should appear before this one
stringListIterator.previous();
stringListIterator.add(newCity);
return true;
} else if (comparison < 0) {
// move on next city
}
}
stringListIterator.add(newCity);
return true;
}
private static void visit(LinkedList cities) {
Scanner scanner = new Scanner(System.in);
boolean quit = false;
boolean goingForward = true;
ListIterator<String> listIterator = cities.listIterator();
if (cities.isEmpty()) {
System.out.println("No cities in the itinerary");
} else {
System.out.println("Now visiting " + listIterator.next());
printMenu();
}
while (!quit) {
int action = scanner.nextInt();
scanner.nextLine();
switch (action) {
case 0 -> {
System.out.println("Holiday (Vacation) over");
quit = true;
}
case 1 -> {
if (!goingForward) {
if (listIterator.hasNext()) {
listIterator.next();
}
goingForward = true;
}
if (listIterator.hasNext()) {
System.out.println("Now visiting " + listIterator.next());
} else {
System.out.println("Reached the end of the list");
}
}
case 2 -> {
if (goingForward) {
if (listIterator.hasPrevious()) {
listIterator.previous();
}
goingForward = false;
}
if (listIterator.hasPrevious()) {
System.out.println("Now visiting " + listIterator.previous());
} else {
System.out.println("We are at the start of the list");
}
}
case 3 -> printMenu();
}
}
}
private static void printMenu() {
System.out.println("Available action:\nPress ");
System.out.println("0 - to quit");
System.out.println("1 - go to next city");
System.out.println("2 - go to previous city");
System.out.println("3 - print menu options");
}
}
########################################################
2.4.2.3. Main.java
import java.util.ArrayList;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
testLinkedlist();
exercise1();
}
public static void exercise1() {
Customer customer = new Customer("Tim", 54.96);
Customer anotherCustomer = customer; // anotherCustomer dang tro den customer
anotherCustomer.setBalance(12.18);
System.out.println("Balance for customer " + customer.getName() + " is " + customer.getBalance());
ArrayList<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(3);
intList.add(4);
for (int i = 0; i < intList.size(); i++) {
System.out.println(i + ": " + intList.get(i));
}
intList.add(1, 2);
for (int i = 0; i < intList.size(); i++) {
System.out.println(i + ": " + intList.get(i));
}
}
public static void testLinkedlist() {
LinkedList<String> cars = new LinkedList<>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
cars.addFirst("Abc");
cars.addLast("Def");
System.out.println(cars);
cars.removeFirst();
cars.removeLast();
System.out.println(cars);
System.out.println(cars.getFirst());
System.out.println(cars.getLast());
LinkedList<Object> myLinkedList = new LinkedList<>();
myLinkedList.add(1);
myLinkedList.add("Thieu");
myLinkedList.add(2.3);
}
}
###########################
2.5. map
2.5.1. linkedhashmap
2.5.2. treemap
2.5.3. hasmap
2.5.3.1. Maps.java
import java.util.HashMap;
import java.util.Map;
/*
* Map: key - value
* key khong duoc trung, moi key se anh xa toi mot value duy nhat
*
* ham put() se tra ve gia tri value truoc do
*/
public class Maps {
public static void main(String[] args) {
Map<String, String> languages = new HashMap<>();
languages.put("Java", "a compiled high level, object-oriented, platform independant language");
languages.put("Python", "an interpreted, object-oriented, high level programming language with dynamic semantics");
languages.put("Algol", "an algorithmic language");
languages.put("BASIC", "Beginners All PURPOSES SYMBOLIC INSTRUCTION CODE");
System.out.println(languages.put("Lisp", "Therein lies madness"));
System.out.println(languages.get("Java"));
System.out.println(languages.put("Java", "this is a Java course"));
System.out.println(languages.get("Java"));
if (languages.containsKey("Python")) {
System.out.println("Python is already in the map");
} else {
System.out.println("I love Python");
}
System.out.println("======================================================================================");
//languages.remove("Lisp");
if (languages.remove("Algol", "a family of algorithmic languages")) {
System.out.println("Algol Removed");
} else {
System.out.println("Algol not removed, key/value pair not found");
}
System.out.println(languages.replace("Scala", "this will not be added"));
if (languages.replace("Lisp", "Therein lies madness",
"a functional programming language with imperative features")) {
System.out.println("Lisp replaced");
} else {
System.out.println("Lisp was not replaced");
}
System.out.println("======================================================================================");
for (String key: languages.keySet()) {
System.out.println(key + " : " + languages.get(key));
}
}
}
################################################
2.6. set
2.6.1. linkedhashset
2.6.2. treeset
2.6.3. hashset
2.6.3.1. HeavenIyBody.java
import java.util.HashSet;
import java.util.Set;
public final class HeavenIyBody {
private final String name;
private final double orbitalPeriod;
private final Set<HeavenIyBody> satellites;
public HeavenIyBody(String name, double orbitalPeriod) {
this.name = name;
this.orbitalPeriod = orbitalPeriod;
this.satellites = new HashSet<>();
}
public String getName() {
return name;
}
public double getOrbitalPeriod() {
return orbitalPeriod;
}
public boolean addMoon(HeavenIyBody moon) {
return this.satellites.add(moon);
}
public Set<HeavenIyBody> getSatellites() {
return new HashSet<>(this.satellites);
}
}
##########################################
2.6.3.2. SetAndHashSet.java
/*
* set la tap hop khong co thu tu xac dinh va khong chua cac phan tu trung lap
*/
public class SetAndHashSet {
private static Map<String, HeavenIyBody> solarSystem = new HashMap<>();
private static HashSet<HeavenIyBody> planets = new HashSet<>();
public static void main(String[] args) {
HeavenIyBody abc = new HeavenIyBody("Thieu", 12);
planets.add(abc);
System.out.println(planets.contains(abc));
TreeSet<Integer> set = new TreeSet<>();
set.add(1);
set.add(2);
set.add(10);
set.add(20);
set.add(8);
for(int i : set) {
System.out.println(i);
}
}
}
#########################################
Editor is loading...
Leave a Comment