Java的所有变量和函数都要定义在class中
内置数据类型
类型 | 字节数 |
---|---|
byte | 1 |
short | 2 |
int | 4 |
long | 8 |
float | 4 |
double | 8 |
boolean | 1 |
char | 2 |
常量
使用final
修饰
final int N = 110;
类型转换
int x = (int) 'A'
double x = 12, y = 4 * 3.3
,低精度向高精度输入
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next(); //读入下一个字符串
int x = sc.nextInt(); //读入下一个整数
float y = sc.nextFloat(); //读入下一个单精度浮点数
double z = sc.nextDouble(); //读入下一个双精度浮点数
String line = sc.nextLine(); //读入下一行
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();//读一行字符串
int x = Integer.parseInt(br.readLine());//读一个整数
// 读入多个整数时
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] strs = br.readLine().split(" ");
int x = Integer.parseInt(strs[0]), y = Integer.parseInt(strs[1]);
}
}
输出
方式1:效率较低,输出规模较小时使用
System.out.println();
System.out.print();
System.out.printf("%.2f\n", 3.1415); //float与double都用%f
方式2:效率较高,输出规模较大时是要用。需要抛出异常
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
public class Main {
public static void main(String[] args) throws Exception{
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
bw.write("Hello world\n");
bw.flush();//需要手动刷新缓冲区
}
}
IF-ELSE、SWICTH与C++完全一样
逻辑表达式与条件判断语句与C++完全一样,但是java中int型不能用作bool类型
循环结构:WHILE, DO-WHILE, FOR循环等与c++完全一样
初始化
初始化定长数组,长度可以是变量,可以在初始化时赋值
int[] a = new int[5]; //初始长度为5的int数组,初始值为0
int n = 10;
float[] b = new float[n]; //初始化长度为n的float数组,初始值为0.0F
char[] c = {'a', 'b', 'c'}; //初始化长度为3的char数组,初始值为:'a', 'b', 'c'
char[] d = c;// d与c地址相同,更改c中的元素,d中的元素也会改变
多维数组
int[][] a = new int[2][3];
a[1][2] = 1;
int[][] b = {
{1, 2, 3},
{4, 5, 6},
};
多维数组输出
System.out.println(Arrays.deepToString(b));
常用API
String类
初始化:
String a = "Hello World";
String b = "My name is";
String x = b; //存储到了相同的地址
String c = b + "Lihua"; // String 可以通过加号拼接
String d = "My age is " + 18; //int 类型会被转换成字符串
String str = String.format("My age is %d", 18); //格式化字符串
String money_str = "123.45";
double money = Double.parseDouble(money_str);// 将String 转换成浮点数
只读变量,不能修改
String a = "Hello ";
System.out.println(a.hashCode());
a += "World";
System.out.println(a.hashCode());// 会发现a变量的地址发生变化了
访问String中的字符
String str = "Hello World";
for (int i = 0; i < str.length(); i ++)
System.out.print(str.charAt(i));//只能读取,不能写入
常用API:
length()
: 返回长度
split(String regex)
: 分割字符串
str.indexOf(char c)、indexOf(String str)
: 查找,找不到返回-1
equals()
: 判断两个字符串是否相等,而不能用==
compareTo()
: 判断两个字符串字典序大小,负数表示小于,0表示相等,整数表示大于
startsWith()
: 判断是否以某个前缀开头
endsWith()
: 判断是否以某个后缀结尾
trim()
: 去掉首位的空白字符
toLowerCase()
: 全部用小写字符
toUpperCase()
: 全部用大写字符
replace(char oldChar, char newChar)
: 替换字符
replace(String oldRegex, String newRegex)
: 替换字符串
substring(int beginIndex, int endIndex)
: 返回[beginIndex, endIndex)中的子串
StringBuilder
、StringBuffer
String
不能被修改,如果打算修改字符串,可以使用StringBuilder
和StringBuffer
。StringBuffer
线程安全(多线程要使用),速度较慢;StringBuilder
线程不安全速度较快StringBuilder sb = new StringBuilder("Hello "); //初始化
sb.append("World");//拼接字符串
System.out.println(sb);
for (int i = 0; i < sb.length(); i ++){
sb.setCharAt(i, (char)(sb.charAt(i) + 1));// 读取和写入字符
}
System.out.println(sb);
reverse
java的所有变量和函数都要定义在类中。
函数或变量前加 static
表示静态对象,类似全局变量。共用。
静态对象属于 class
,而不属于class
的具体实例,
使用静态函数,在调用时可以使用类名调用,非静态函数只能使用具体实例进行调用
静态函数中只能调用静态函数和静态变量。
例:
import java.util.Arrays;
public class Main{
public static void main(String[] args){
System.out.println(max(3, 4));
int[][] a = new int[3][4];
fill(a, 3);
int[][] b = getArray2d(2, 3, 5);
System.out.println(Arrays.deepToString(b));
}
private static int max(int a, int b){
if (a > b) return a;
return b;
}
private static void fill(int[][] a, int val){
for (int i = 0; i < a.length; i ++)
for (int j = 0; j < a[i].length; j ++)
a[i][j] = val;
}
private static int[][] getArray2d(int row, int col, int val){
int[][] a = new int[row][col];
for (int i = 0; i < row; i ++)
for (int j = 0; j < col; j ++)
a[i][j] = val;
return a;
}
}
源文件声明规则
public
类public
类public
类的类名保持一致package
语句,再写import
语句,最后定义类类的定义
public
:所有对象均可以访问private
:只有自己可以访问例:
class Point{
private int x, y;
public Point(int x, int y){// 构造函数
this.x = x;
this.y = y;
}
public int getx(){
return x;//私有变量不能直接访问,需要定义接口
}
public int gety(){
return y;
}
public String toString(){
return String.format("(%d, %d)", x, y);
}
}
类的继承
每个类只能继承一个类
extends
继承对应的父类
super
就表示父类的意思
class ColorPoint extends Point{
private String color;
public ColorPoint(int x, int y, String color) {
super(x, y);
this.color = color;
}
public String toString() {
return String.format("%d, %d, %s", super.getx(), super.gety(), this.color);
}
}
类的多态
多态:同一个类的实例,调用相同的函数,运行的结果不同
Point point = new Point(3, 4);
Point colorPoint = new ColorPoint(1, 2, "red");//这两个变量都是同一个类型
System.out.println(point.toString());
System.out.println(colorPoint.toString());//不同的行为
接口
interface
与class
类似。主要用来定义类中所需包含的函数。
接口也可以继承其他接口,一个类可以实现多个接口
接口的定义
interface Role{
public void greet();
public void move();
public int getSpeed();
}
接口的继承
每个接口可以继承多个接口
interface Hero extends Role{
public void attack();
}
接口的实现
每个类可以实现多个接口
class Zeus implements Hero{
private final String name = "Zeus";
public void attack(){
System.out.println(name + "attack!");
}
public void greet(){
System.out.println(name + "Hi!");
}
public void move(){
System.out.println(name + "Move!");
}
public int getSpeed(){
return 10;
}
}
接口的多态
public class Main{
public static void main(String[] args){
Hero[] heros = {new Zeus(), new Athena()};// 可以使用基接口表示不同子类对象
for (Hero hero : heros){
hero.greet();
}
}
}
泛型
类似于C++
中的template
, Java
的类和接口可以定义泛型,即同一套函数可以作用于不同的对象类型。
泛型只能使用对象类型,不能使用基本变量类型。
类似于c++
中的vector
接口:java.util.List<>
实现:
java.util.ArrayList<>
:变长数组java.util.LinkedList<>
:双链表函数:
add()
:在末尾添加一个元素clear()
:清空size()
:返回长度isEmpty()
:是否为空get(i)
:获取第i个元素set(i, val)
:将第i个元素设置为val类:java.util.Stack<>
函数:
push()
:压入元素pop()
:弹出栈顶元素,并返回栈顶元素peek()
:返回栈顶元素empty()
:栈是否为空clear()
:清空接口: java.util.Queue<>
实现:
java.util.LinkedList<>
:双链表java.util.PriorityQueue<>
:优先队列函数:
add()
: 在队尾添加元素remove()
:删除队头isEmpty()
:是否为空size()
:返回长度peek()
:返回队头clear()
:清空接口:java.util.Set<>
实现:
java.util.HashSet<>
: 哈希表(无序)java.util.TreeSet<>
:平衡树(有序)函数:
add()
:添加元素contains()
:是否包含某个元素remove()
:删除元素size()
:返回元素数isEmpty()
:是否为空clear()
:清空java.util.TreeSet
多的函数:
ceiling(key)
: 返回大于等于key
的最小元素,不存在则返回null
floor(key)
:返回小于等于key
的最大元素,不存在则返回null
接口:java.util.Map<K, V>
实现:
java.util.HashMap<K, V>
: 哈希表java.util.TreeMap<K, V>
:平衡树函数:
put(key, val)
:添加关键字和对应的值get(key)
:返回关键字对应的值containsKey(key)
:是否包含关键字remove(key)
:删除关键字size()
:返回关键字isEmpty()
:是否为空clear()
:清空entrySet()
:获取Map
中的所有对象的集合Map.Entry<K, V>
:Map
中的对象类型
getKey()
:获取关键字getValue()
:获取值java.util.TreeMap<K, V>
多的函数:
ceilingEntry(key)
:返回大于等于key
的最小元素,不存在则返回null
floorEntry(key)
:返回小于等于key
的最大元素,不存在则返回null