Java 复习

阅读量：6819 次

发布时间：2019-06-26

本文共 20590 字，大约阅读时间需要 68 分钟。

基本知识点

文件名必须和类型一致，类名首字母要大写，例如：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
    
      {    private T object;    public void set(T object) { this.object = object; }    public T get() { return object; }}

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

Box
    
      box = new Box
     
      ();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

参考：

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 会自动创建。

修饰符分为两种：

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 的方法组织在一起。

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

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

// interfaceinterface 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 interfaceclass 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 SecondInterfaceclass 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 classpublic 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 classpublic class MyClass {   public static void main(String[] args) {     ArrayList
    
      cars = new ArrayList
     
      (); // 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
      
        myNumbers = new ArrayList
       
        ();    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
    
      capitalCities = new HashMap
     
      ();    // 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));}  }}

使用 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.txtAbsolute path: C:\Users\MyName\filename.txtWriteable: trueReadable: trueFile size in bytes: 0

import java.io.FileWriter;   // Import the FileWriter classimport java.io.IOException;  // Import the IOException class to handle errorspublic 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();    }   } }

输出：