Java 复习

基本知识点

文件名必须和类型一致，类名首字母要大写，例如：MyClass

注释-Commonts

Java 注释（Java Comments），单行注释 //，在 // 至当前行行位之间的内容，都会被忽略
多行注释：/*被注释的内容 */，

变量-Variables

String 存储文本，例如 "hello"，用双引号包含值
char 存储单个字符（character），例如 "B"，用双硬汉包含值
int 存储没有小数点的整数，例如 "123" "-123"
float 存储浮点数，有小数点的，例如 "19.99" "-19.99"
boolean 存储布尔值，有两个状态： true 或 false
声明变量的语法：type variable = value; ，例如：
- String name = "Michael;"
- boolean myBool = true;
- float myFloatNum = 5.99f; // floating point number
- 同时声明多个同类型的变量 int x =5, y = 6;
必须使用唯一名称标识所有Java变量，这些唯一名称称为标识符（identifiers）。变量名有一些规范：
- 变量名可以包含字母、数字、下划线、$符号
- 变量名可以 $、_、字母开头
- 变量名建议小写字母开头，不能包含空格
- 「保留字」不能作为变量名

数据类型-Data Types

数据类型分为两组：

原始数据类型（Primitive data types）：byte, short, int, long, float, double, boolean and char
数字
- Integer types 整形数字，没有小数点
  - byte 字节 = 8 bit 位，-128 to 127，例：byte myNum = 100;
  - short = 2 bytes -32,768 to 32,767，例：short myNum = 5000;
  - int = 4 bytes，int 类型是我们首选的数字类型，例：int myNum = 100000;
  - long = 8 bytes，应该要以 L 结尾，例：long myNum = 15000000000L;
- Floating point types 浮点数类型
  - float = 4 bytes，应该要以 f 结尾，例：float myNum = 5.75f;
  - double = 8 bytes，在大多数计算中使用double更安全，应该要以 d 结尾，例：double myNum = 19.99d;
boolean = 1 byte 存储值只能是 true or false，例：boolean isJavaFun = true;
char = 2 bytes 存储单个字符（character）或字母（letter），char 值必须用单引号括起来例，char myGrade = 'B';
String 类型的值必须是以双引号括起来，例：String greeting = "Hello World";
非原始数据类型（Non-primitive data types）：例如 String, Arrays and Classes
非原始数据类型称为「引用类型」，因为他们引用「objects」。它们和原始数据类型的区别在：
- 原始类型是 Java 中预定义的。非原始类型是由程序员定义的（除了 String）。
- 非基本类型可用于调用方法来执行某些操作，而基本类型不行。
- 基本类型始终有值，而非基本类型可以为 null。
- 基本类型以小写字母开头，而非基本类型以大写开头。
- 非基本类型包含 String,Arrays,Classes,Interface,etc

泛型

泛型是Java SE 1.5 的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

public class Box<T> {
    private T object;

    public void set(T object) { this.object = object; }
    public T get() { return object; }
}

创建一个Box对象，带泛型参数，获取对象的时候就不需要强制转换

Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();

总结下泛型的好处就是：省去了强制转换，可以在编译时候检查类型安全，可以用在类，方法，接口上

下来说说泛型通配符T，E，K，V区别

这些全都属于java泛型的通配符，刚开始我看到这么多通配符，一下晕了，这几个其实没什么区别，只不过是一个约定好的代码，也就是说

使用大写字母 A,B,C,D......X,Y,Z 定义的，就都是泛型，把 T 换成 A 也一样，这里 T 只是名字上的意义而已

? 表示不确定的java类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表 java 键值中的 Key Value
E (element) 代表 Element

参考：

简书JAVA泛型通配符T，E，K，V区别，T以及Class，Class<?>的区别

Strings

String Length，例：String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";int len = txt.length();
toUpperCase()、toLowerCase() 方法，将值变为全大写、全小写
indexOs() 返回在字符串中第一次出现的索引位置，和 Python 一样，也是从 0 开始的；
+ 操作符可以字符串连接（concatenation）；
concat() 方法也可以 concatenate 两个字符串：System.out.println(firstName.concat(lastName));，将 "20"+10，结果是 “2010“，字符串类型；

Math

Math.random() 返回 0(inclusive) to 1 (exclusive) 范围的值，0≤x<1

If...Else

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

栗子：

int time = 22;
if (time < 10) {
  System.out.println("Good morning.");
} else if (time < 20) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}

三元运算符（Ternary Operator）

variable = (condition) ? expressionTrue : expressionFalse;

栗子：

int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";

Switch

switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

break; 语句要记得写，不然一直往下执行，直到遇到 break;
default 语句是用来当没有匹配条件时执行的，它不需要 break

While 循环

while (condition) {
  // code block to be executed
}

Do/While 循环是上面那种写法的一个变体（variant）。这个循环是在检查条件之前，就会直接执行一次代码！然后判断条件，执行循环。

do {
  // code block to be executed
}
while (condition);

For 循环

for (statement 1; statement 2; statement 3) {
  // code block to be executed
}

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程

For-Each 循环

for (type variable 声明语句: arrayname 数组名) {
  // code block to be executed
}

栗子：

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
  System.out.println(i);
}

Arrays 数组

Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value.
数组用于在单个变量中存储多个值，而不是为每个值声明单独的变量。

栗子：

// 用变量类型+方括号（square brackets）
String[] cars;
// 在大括号内（inside curly braces）放入值
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

数组元素的操作：

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]); // 输出首个元素
cars[0]="Opel"; // 修改首个元素值
System.out.println(cars.length); // 数组的长度，这里不用调用方法
// 数组的循环
for (int i=0;i < cars.length; i++){
  System.out.println(cars[i]);
}
// for-each 循环
for (String i : cars){
  System.out.println(i);
}

多维数组（Multidimensional Arrays）

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7

Exceptions

try {
  //  Block of code to try
}
catch(Exception e) {
  //  Block of code to handle errors
}

栗子🌰：

public class MyClass {
  public static void main(String[] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    } finally {
      System.out.println("The 'try catch' is finished.");
    }
  }
}

finally 语句，不论上面结果如何，最终都要执行；

throw 关键字可以让你创建一个自定义的 error：

public class MyClass {
  static void checkAge(int age) { 
    if (age < 18) {
      throw new ArithmeticException("Access denied - You must be at least 18 years old."); 
    }
    else {
      System.out.println("Access granted - You are old enough!"); 
    }
  } 

  public static void main(String[] args) { 
    checkAge(15); // Set age to 15 (which is below 18...)
  } 
}

Methods 方法

一个方法就是一个代码块，它在被调用时运行。

public class MyClass {
  static void myMethod() {
    // code to be executed
  }
}

myMethod 方法名；
void 表示这个方法没有返回值；
static 表示这个方法属于 MyClass 这个类，不是 MyClass 类的对象。

方法参数

public class MyClass {
  static void myMethod(String fname) {
    System.out.println(fname + " Refsnes");
  }

  public static void main(String[] args) {
    myMethod("Liam");
    myMethod("Jenny");
    myMethod("Anja");
  }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

方法返回值

public class MyClass {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(5, 3));
  }
}
// Outputs 8 (5 + 3)

Java Classes 类

类和对象 Classes and Objects

Java 是一个 OOP 语言（object-oriented programming），面向对象编程。

对象具有属性（attributes）和方法（methods）。

创建对象：

public class MyClass {
  int x = 5; // 这里的 x 就是 MyClass 的 attribute，也叫 fields

  public static void main(String[] args) {
    MyClass myObj1 = new MyClass();  // Object 1
    MyClass myObj2 = new MyClass();  // Object 2
    myObj2.x = 25;
    System.out.println(myObj1.x);  // Outputs 5
    System.out.println(myObj2.x);  // Outputs 25
  }
}

发现在当前定义的类中，就已经可以用这个类创建对象了；
类名首字母就要大写啦，它是非原始类型的数据类型；
类名要和文件名一致；
两个类文件在同一级目录下，直接可以调用另一个类创建对象，不像 Python 还需要 import 模块；
创建多个对象时，及时一个对象的属性值修改了，不会影响到其他对象的属性值；

final 关键字：
如果你不像类属性在后面被修改，可以使用 final 关键字声明属性

public class MyClass {
  final int x = 10;
  public static void main(String[] args) {
    MyClass myObj = new MyClass();
    myObj.x = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x); 
  }
}

会报错：Error:(8, 14) java: 无法为最终变量x分配值
final 关键字在你想要让一个变量总是存储同样的值（也就是值不变）时，很有用；
final 被叫做修饰符（modifier）；

Methods 方法

public class MyClass {
  static void myMethod() {
    System.out.println("Hello World!");
  }

  public static void main(String[] args) {
    myMethod(); // 没有创建对象，就可以调用方法，static 的功劳
  }
}

Static or Public

static 方法可以不用创建类的对象就可以被调用，不像 public 方法（只能通过创建对象来调用）

栗子🌰：

public class MyClass {
  // Static method
  static void myStaticMethod() {
    System.out.println("Static methods can be called without creating objects");
  }

  // Public method
  public void myPublicMethod() {
    System.out.println("Public methods must be called by creating objects");
  }

  // Main method
  public static void main(String[ ] args) {
    myStaticMethod(); // Call the static method
    // myPublicMethod(); This would compile an error

    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method on the object
  }
}

Constructors 构造器

构造器是 Java 中的特殊方法，用来初始化对象。当通过类创建一个对象的时候，构造器就被调用了。它被用来设置对象属性的初始值。

public class Car {
  int modelYear;
  String modelName;

  public Car(int year, String name) {
    modelYear = year;
    modelName = name;
  }

  public static void main(String[] args) {
    Car myCar = new Car(1969, "Mustang");
    System.out.println(myCar.modelYear + " " + myCar.modelName);
  }
}

// Outputs 1969 Mustang

构造器的名字必须和类名相同，它不能有返回值（类似 void）；
所有的类都有构造器。如果你没创建， Java 会自动创建。

修饰符 Modifiers

修饰符分为两种：

1.访问修饰符控制访问等级
- default( 缺省 ) 在同一包内可见，使用对象：类、接口、变量、方法
- public 对所有类可见，使用对象：类、接口、变量、方法
- private 「私有」，在同一类内可见，使用对象：变量、方法。注意：不能修饰类。私有访问修饰符是最严格的访问级别！被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问
- protected 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类。
2.非访问修饰符不控制访问等级，但是提供其他功能
- final 用来修饰类、方法、变量，final 修饰的类不能被继承，修饰的方法不能被继承类重新定义，修饰的变量为「常量」，不可修改。
- static 用来修饰类方法和类变量，类方法、类变量属于类而不是一个对象。对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。
- abstract 修饰符，用来创建抽象类和抽象方法，抽象方法没有方法体，抽象方法只能在抽象类中，否则会报错；但是抽象类中定义非抽象方法是不会报错的；
- synchronized 和 volatile 修饰符，主要用于线程的编程；

Encapsulation 封装

为了实现封装：

声明属性/变量时，使用 private 修饰符（在同一类内可见）；
提供 public setter 和 getter 方法来获取和修改 private 变量；

栗子：

/* 文件名: EncapTest.java */
public class EncapTest{
   private String name;
   private int age;
   
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
    public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
}

this 关键字用来指向当前的对象；

Packages 包

Java 的包是用来将相关类分组的，可以把它看做是一个文件夹。

包的作用：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

Java 包分为两类：

内置包（Built-in Packages），来自 Java API 的包；
用户自定义的包；

Built-in Packages

// 语法
import package.name.Class; // Import a single class 
import package.name.*; // Import the whole package

引入一个类

import java.util.Scanner;

java.util 是一个 package，Scanner 是它的一个类；

引入一个包

import java.util.*;

自定义包

使用 package 关键字：

package mypack;

注意：类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前

继承 Inheritance

subclass(child) 子类
superclass(parent) 超类/父类

为了继承某个类，使用 extends 关键字。

class Vehicle {
  protected String brand = "Ford";         // Vehicle attribute
  public void honk() {                     // Vehicle method
    System.out.println("Tuut, tuut!");
  }
}

class Car extends Vehicle {
  private String modelName = "Mustang";    // Car attribute
  public static void main(String[] args) {

    // Create a myCar object
    Car myCar = new Car();

    // Call the honk() method (from the Vehicle class) on the myCar object
    myCar.honk();

    // Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
    System.out.println(myCar.brand + " " + myCar.modelName); 
  }
}

Vehicle 中使用了一个 protected 修饰符，如果使用了 private 修饰符，那么 Car 类是无法获取 brand 属性的；

Polymorphism 多态

同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

class Animal {
  public void animalSound() {
    System.out.println("The animal makes a sound");
  }
}

class Pig extends Animal { 
// 继承自 Animal
// 重写了 animalSoud 方法
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }
}

class Dog extends Animal {
  public void animalSound() {
    System.out.println("The dog says: bow wow");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Animal myAnimal = new Animal();  // Create a Animal object
    // 父类 指向 子类
    // Parent p = new Child();
    Animal myPig = new Pig();  // Create a Pig object
    Animal myDog = new Dog();  // Create a Dog object

    myAnimal.animalSound();
    myPig.animalSound();
    myDog.animalSound();
  }
}

重写（override）的规则：
- 参数列表必须完全与被重写方法的相同；
- 返回类型必须完全与被重写方法的返回类型相同；
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
- 父类的成员方法只能被它的子类重写。
- 声明为final的方法不能被重写。
- 声明为static的方法不能被重写，但是能够被再次声明
- 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法
- 构造方法不能被重写。
重载（overload）：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载
- 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理

Interface 接口

一个 Interface 是一个抽象类，用来将一些 empty bodies 的方法组织在一起。

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

接口类必须被其他类以关键字 implements 实现，接口方法由「实现」类提供：

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

关于接口的注意点：

接口类不能用于创建对象；
接口方法不能拥有方法体；
接口的实现类，必须重写它所有的方法；
接口方法默认是 abstract 和 public 修饰符；
接口属性默认是public static 和final
一个接口不能包含一个构造器（因为它不能用来创建对象）

Java不支持“多重继承”（一个类只能从一个超类继承）。但是，它可以通过接口实现，因为该类可以实现多个接口。注意：要实现多个接口，请使用逗号分隔它们（请参阅下面的示例）。

interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

// DemoClass "implements" FirstInterface and SecondInterface
class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

抽象类和接口的区别：

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

Enums 枚举类

枚举是一个特殊的“类”，它表示一组常量（不变的变量，如 final 变量）。


enum Level {
  LOW, // 常量用逗号隔开，必须用大写字母
  MEDIUM,
  HIGH
}

Level myVar = Level.MEDIUM; // 获取枚举的常量值

myVar 类型就是 Level，不是 String

循环：

for (Level myVar : Level.values()) {
  System.out.println(myVar);
}

User Input 用户输入

Scanner 类用于获取用户输入，它在 java.util 包中。

nextBoolean() 从用户获取 boolean 值
nextByte() 从用户获取一个字节的值
nextDouble
nextFload
nextInt()
nextLine()
nextLong()
nextShort()

栗子🌰：

import java.util.Scanner;

class MyClass {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);

    System.out.println("Enter name, age and salary");

    // String input
    String name = myObj.nextLine();

    // Numerical input
    int age = myObj.nextInt();
    double salary = myObj.nextDouble();

    // Output input by user
    System.out.println("Name: " + name); 
    System.out.println("Age: " + age); 
    System.out.println("Salary: " + salary); 
  }
}

Data and Time 日期和时间

Java 没有内置的 Date 类，可以通过引入 java.time 包来使用。这个包包含许多日期和时间类，例如：

Class	描述
`LocalDate`	表示日期，year,month,day(yyyy-MM-dd)
`LocalTime`	表示时间，hour,minute,second and microsecond(HH-mm-se-zzz)
`LocalDateTime`	表示日期和时间 (yyyy-MM-dd-HH-mm-ss.zzz)
`DateTimeFormatter`	用于显示和解析日期时间对象的Formatter

Current Date /当前时间 Current Time 显示当前日期

import java.time.LocalDate; // import the LocalDate class 引入 LocalDate  类
import java.time.LocalTime; // import the LocalTime class
public class MyClass { 
  public static void main(String[] args) { 
    // 当前日期
    LocalDate myObj = LocalDate.now(); // Create a date object 可以看到，这里创建对象没有使用 new 关键字
    System.out.println(myObj); // Display the current date
	//2018-12-28
	
	// 当前时间
    LocalTime myObj = LocalTime.now();
    System.out.println(myObj);
    // 15:34:46.622
	// 可以看到，这里的时间格式并不是很好看

   // 显示当前日期和时间
   LocalDateTime myDateTime = LocalDateTime.now();
   // 2018-12-28T15:36:56.581

	// 格式化日期和时间 ★★★
	// 1  now 方法创建时间日期对象
	LocalDateTime myDateObj = LocalDateTime.now(); 
    System.out.println("Before formatting: " + myDateObj); 
    // 2 创建格式化器对象
    DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss"); 
	// 3 时间日期对象调用格式化器
    String formattedDate = myDateObj.format(myFormatObj); 
    System.out.println("After formatting: " + formattedDate); 
  } 
}

ofPattern() 方法接受各种值的排序，如果你想要显示一个不同格式的日期时间值，可以这么做：

yyyy-MM-dd "1988-09-29"
dd/MM/yyyy "29/09/1988"
dd-MMM-yyyy "29-Sep-1988"
E, MMM dd yyyy "Thu, Sep 29 1988"

更多日期格式，可以查看：

ArrayList 数组列表

ArrayList 类一个大小可调整（resizeable）的数组（array），这个类位于 java.util 包中。

和内置的数组相比，内置数组的大小是不可变的（如果你要增加 or 删除数组的元素，你必须新建一个新的数组），而 ArrayList 可以新增、删除元素。

栗子：

import java.util.ArrayList; // import the ArrayList class

public class MyClass { 
  public static void main(String[] args) { 
    ArrayList<String> cars = new ArrayList<String>(); // Create an ArrayList object
	// Add Items
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars);
	// Access an Item
	System.out.println(cars.get(0));
	// Change an Item
	cars.set(0,"VV5"); // return oldValue
	// Remove an Item
	cars.remove(0); // return oldValue
	cars.clear(); // 删除全部元素
	// Size
	cars.size(); // get how many elements 
	for (String i : cars) {
      System.out.println(i);
    }
    // 或者这么写
    for(int i = 0; i < cars.size(); i++){
      System.out.println(cars.get(i));
    }

	// java.util 包中还有一个有用的 `Collections` 类，它包含了 sort() 方法，可以字母排序或者数字排序
    ArrayList<Integer> myNumbers = new ArrayList<Integer>();
    myNumbers.add(33);
    myNumbers.add(15);
    myNumbers.add(20);
    myNumbers.add(34);
    myNumbers.add(8);
    myNumbers.add(12);

    Collections.sort(myNumbers);  
    // Sort myNumbers，这在 Python 中属于就地改变的一种排序 in place，因为它直接改变了 myNumbers 这个列表的元素顺序

    for (int i : myNumbers) {
      System.out.println(i);
    }
  }
}

add 方法其实还可以指定插入的索引位置，这就是利用了 Java 中「重载」的概念，方法名一样，参数不一样-》表现行为就不一样。

参考：

HashMap

HashMap 使用「键值对」的方式存储元素，感觉就是和 Python 中的字典一个效果。

import java.util.HashMap;

public class MyClass {
  public static void main(String[] args) {
	// 创建了一个 HashMap  对象，它存储 String 类型的 键，存储 String 类型的值
    // Create a HashMap object called capitalCities
    HashMap<String, String> capitalCities = new HashMap<String, String>();

    // Add keys and values (Country, City)
    capitalCities.put("England", "London");
    capitalCities.put("Germany", "Berlin");
    capitalCities.put("Norway", "Oslo");
    capitalCities.put("USA", "Washington DC");
    System.out.println(capitalCities); 
	// Access an Item
	capitalCities.get("England");
	//Remove an Item
	capitalCities.remove("England");
	//Remove all 
	capitalCities.clear();
	//HashMap Size
	capitalCities.size();
	//循环，keySet() 只返回 keys
	//values() 只返回 values
	// Print keys and values
	for (String i : capitalCities.keySet()) {
  	  System.out.println("key: " + i + " value: " + capitalCities.get(i));
}
  }
}

Files 文件

使用 File 类创建一个对象，指定文件名或者目录名：

import java.io.File; 

public class GetFileInfo { 
  public static void main(String[] args) { 
    File myObj = new File("filename.txt");
    // Get file info
    if (myObj.exists()) {
      System.out.println("File name: " + myObj.getName()); 
      System.out.println("Absolute path: " + myObj.getAbsolutePath()); 
      System.out.println("Writeable: " + myObj.canWrite()); 
      System.out.println("Readable " + myObj.canRead()); 
      System.out.println("File size in bytes " + myObj.length());
    } else {
      System.out.println("The file does not exist.");
    }
  } 
}

输出：

File name: filename.txt
Absolute path: C:\Users\MyName\filename.txt
Writeable: true
Readable: true
File size in bytes: 0

import java.io.FileWriter;   // Import the FileWriter class
import java.io.IOException;  // Import the IOException class to handle errors

public class WriteToFile { 
  public static void main(String[] args) { 
    try { 
      FileWriter myWriter = new FileWriter("filename.txt");
      myWriter.write("Files in Java might be tricky, but it is fun enough!");
      myWriter.close(); //当写好文件之后，需要关闭
      System.out.println("Successfully wrote to the file.");
    } catch (IOException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    } 
  } 
}

输出：

Successfully wrote to the file.

常用方法

System.out.println("Hello World"); 打印信息

FAQ

Java中如何理解父类的引用指向类的对象？

知乎-Java中如何理解父类的引用指向类的对象。。初学者。。？介绍的很棒，多态的妙处！

教程

w3schools-Java Tutorial 虽然是英文版，但还是比较通俗易懂的，推荐；

posted @ 2019-03-03 19:01 Michael翔阅读(561) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Michael翔

公众号『Coder魔法院』，效率软件控，欢迎关注！因上努力，果上随缘，做好自己！

Java 复习

基本知识点

注释-Commonts

变量-Variables

数据类型-Data Types

泛型

下来说说泛型通配符T，E，K，V区别

Strings

Math

If...Else

Switch

While 循环

For 循环

Arrays 数组

Exceptions

Methods 方法

Java Classes 类

类和对象 Classes and Objects

Methods 方法

Constructors 构造器

修饰符 Modifiers

Encapsulation 封装

Packages 包

继承 Inheritance

Polymorphism 多态

Interface 接口

Enums 枚举类

User Input 用户输入

Data and Time 日期和时间

Current Date /当前时间 Current Time 显示当前日期

ArrayList 数组列表

HashMap

Files 文件

常用方法

FAQ

Java中如何理解父类的引用指向类的对象？

教程

公告

Michael翔

公众号『Coder魔法院』，效率软件控，欢迎关注！ 因上努力，果上随缘，做好自己！

Java 复习

基本知识点

注释-Commonts

变量-Variables

数据类型-Data Types

泛型

下来说说泛型通配符T，E，K，V区别

Strings

Math

If...Else

Switch

While 循环

For 循环

Arrays 数组

Exceptions

Methods 方法

Java Classes 类

类和对象 Classes and Objects

Methods 方法

Constructors 构造器

修饰符 Modifiers

Encapsulation 封装

Packages 包

继承 Inheritance

Polymorphism 多态

Interface 接口

Enums 枚举类

User Input 用户输入

Data and Time 日期和时间

Current Date /当前时间 Current Time 显示当前日期

ArrayList 数组列表

HashMap

Files 文件

常用方法

FAQ

Java中如何理解父类的引用指向类的对象？

教程

公告

公众号『Coder魔法院』，效率软件控，欢迎关注！因上努力，果上随缘，做好自己！