JAVA之路
前言
记录自己的JAVA学习过程
Java基础教程记录
大致阅读本教程,总结如下。
Java基础
- 整数类型 byte,short,int,long(加L后缀)
注:分别对应 1字节,2字节,4字节,8字节(1byte=8bit 即八位二进制数) - 浮点书类型 float(加f后缀),double
- 字符类型 char
- 布尔类型 boolean(true or false)
- 引用类型 String
- 常量 final修饰符 eg. final double PI=3.14
- var 关键字 自动推断变量类型 eg. var i = “hello”
- 强制转化 short s = (short) i
- 如果参与运算的两个数其中一个是整型,那么整型可以自动提升到浮点型 <与c/c++相同>
- 三元运算符 b ? x : y
b为true则x,否则y - 字符类型 char 保存一个Unicode字符 eg. char c=‘A’
- 字符串类型 String s = “linsanity”
注:字符串连接可用+ ; - 关于字符串的指向
- 数组
两种建立数组的方式
public class HelloWorld {
public static void main(String[] args){
int[] n = new int[5];
int[] m = new int[] {0,1,2,3,4};
for(int i=0;i<n.length;i++) {
n[i] = i;
}
System.out.println(n[2]+" "+m[2]);
}
//output: 2 2
}
- 关于字符串数组
注:String s= names[1]; s指向 names[1]所指向的内容,即“XYZ” - 输出
public class HelloWorld {
public static void main(String[] args){
String[] names={"kobe","wade","lebron","lin","irving"};
System.out.println(names[0]+" "+names[1]);//println自带换行
//kobe wade
System.out.print(names[2]+" "+names[3]+"\n");//print无换行
//lebron lin
System.out.printf("%s,%.2f\n",names[4],3.1415);//printf格式输出<类似c>
//irving,3.14
}
}
- 输入
package first.demo;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args){
Scanner s = new Scanner(System.in);
System.out.print("name:");
String name = s.nextLine(); //读取输入的一行
//name:lin
System.out.print("num:");//读取输入的数
int num = s.nextInt();
//num:7
System.out.println(name+" "+num);
//output:lin 7
}
}
- if else swith for while 与c/c++ 类似
- 引用类型(eg.string) 判断是否相同时,不能用“==”,用equals()
public class HelloWorld {
public static void main(String[] args){
String[] names={"kobe",null};
for(int i=0;i<names.length;i++) {
if (names[i] != null && names[i].equals("kobe")) //不加前半段判断null会报错
System.out.println("yep");
else
System.out.println("none");
}
//output:yep
// none
}
}
- 数组排序+遍历输出 Arrays
Arrays.sort() 升序排序
Arrays.toString() 打印整个数组
import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
Arrays.sort(ns);
System.out.println(Arrays.toString(ns));
}
//output:[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
}
类和对象
- 类名命名 大写字母开头 Hello;NoteBook
- 方法命名 小写字母开头 main;setName
引用类型包含 1.数组 2.字符串 3.字符串数组 等 ,类似c语言中的指针。
基本类型参数的传递,是调用方值的复制。双方各自的后续修改,互不影响。
当引用类型进行参数传递时要注意 参数绑定
import java.util.Arrays;
//类似 main函数
public class Linsanity { //类
public static void main(String[] args){ //方法
Player mamba = new Player(); //新建实例(instance)
mamba.setName("Kobe","Bryant");
System.out.println(Arrays.toString(mamba.getName())); //Arrays.toString 打印整个数组
//output: kobe,Bryant
mamba.setCharacters(198,24);
System.out.println((Arrays.toString(mamba.getCharacters())));
//output: 198,24
//引用参数绑定
Player linsanity = new Player();
String[] name1 = {"Jeremy","Lin"};
int[] characters1 ={191,17};
int age1 = 30;
String country1 = "USA";
linsanity.setAge(age1);
linsanity.setName(name1);
linsanity.setCharacters(characters1);
linsanity.setCountry(country1);
System.out.println(Arrays.toString(linsanity.getName()));
System.out.println(Arrays.toString(linsanity.getCharacters()));
System.out.println(linsanity.getAge());
System.out.println(linsanity.getCountry());
//output:Jeremy,Lin
//output:191,17
//output:30
//output:USA
name1[0] = "Shuhao";
characters1[1] = 7;
age1 = 31;
country1 = "China";
System.out.println(Arrays.toString(linsanity.getName()));
System.out.println(Arrays.toString(linsanity.getCharacters()));
System.out.println(linsanity.getAge());
System.out.println(linsanity.getCountry());
//output:Shuhao,Lin
//output:191,7
//output:30
//output:USA
characters1 = new int[]{191,3};
System.out.println(Arrays.toString(linsanity.getCharacters()));
//output:191,7
}
}
class Player{ //类
//定义 字段(field)
private String[] fullname; //第一位名,第二位姓
private int[] characters; //第一位身高,第二位号码
private int age;
private String country;
public void setName(String... fullname){ //String... 可变类型
this.fullname = fullname; //this指该对象的fullname
}
public String[] getName(){
return fullname;
}
public void setCharacters(int... characters){
this.characters = characters;
}
public int[] getCharacters(){
return characters;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void setCountry(String country){
this.country = country;
}
public String getCountry(){
return country;
}
}
- 继承 extends
- 重载 overload 方法名相同,参数不同
- 重写(多态)override 子类定义了一个与父类方法签名(参数+返回值)完全一致的方法
- 抽象方法 abstract 方法本身不需要实现任何功能,定义出来仅仅为了子类的覆写
- 抽象类 abstract 抽象方法对应的类
- 接口 interface 如果一个抽象类没有字段,所有方法全部都是抽象方法,就可以把该抽象类改写为接口 。可以把interface看作比抽象类还抽象的类
当一个具体的class去实现(继承)一个interface时,需要使用implements关键字
注:一个类只能继承一个类,但可以实现多个接口 - 静态字段 所有实例(instance)共享,会彼此影响 eg. static int totalnum;
- 静态方法
- 包 package 名字空间,把各个类分到不同的包下,方便使用引用
自带函数用法
max
Math.max(a,b);
数据结构用法
ArrayList
List<Integer> path = new ArrayList<>();
path.add(nms[i]);
path.remove(path.size()-1); //无poll
List<List<Integer>> result = new ArrayList<>();
result.add(new ArrayList<>(path));
//Correct!
//creating a new ArrayList that is a copy of path and adding that to result.
result.add(new ArrayList<>(path));
/*Wrong
If you were to use result.add(path);
you would be adding a reference to the path list, not a new list.
This means that whenever path changes (which it does in your code),
all the references to path you added to result would reflect these changes as well.
This is not what you want in this case.
*/
HashMap
Map<String, Integer> map = new HashMap<String, Integer>();
map.put(s, map.getOrDefault(s,0) + 1);
map.get(s);
map.put(s);
map.containsKey(x)
String 和 char[]
char[] arr = new char[n];
Arrays.fill(arr, '0');
String s = new String(arr);
String 和 StringBuilder
StringBuilder 和 String 都用于处理字符串,但它们有一些重要的区别。
可变性:String 是不可变的,这意味着一旦创建了一个 String 对象,你就不能改变它。
而 StringBuilder 是可变的,所以你可以添加、删除或更改 StringBuilder 的内容。
性能:由于 String 是不可变的,所以每次对 String 进行操作(如连接操作),实际上都会创建一个新的 String 对象。
这可能会导致内存和性能问题。相比之下,StringBuilder 可以在原地进行修改,不需要创建新的对象,所以性能更好。
在你的代码中,由于你需要频繁地添加和删除字符,所以使用 StringBuilder 会更有效。
如果你使用 String,每次添加或删除字符都会创建一个新的字符串,这会降低性能。
如果你的问题是想知道是否可以使用 String 替代 StringBuilder 来完成相同的任务,那么答案是肯定的,但这通常会导致性能下降。
例如,你可以使用 String 的 + 操作符来添加字符,使用 substring 方法来删除字符。但这通常不如使用 StringBuilder 高效
length
int[][] matrix;
int m = matrix.length;
int n = matrix[0].length;
compareTo
//c++
return a < b;
//java
return a.compareTo(b) < 0;
Stack
Stack<Integer> stack = new Stack<>();
int n = temperatures.length;
int[] result = new int[n];
for (int i = 0; i < n; i++) {
while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
int index = stack.pop();
result[index] = i - index;
}
stack.push(i);
}
return result;