Java编程基础
数据转换
1
2将字符串形式的数字转换为int类型
Integer.parseInt(strs[i])，其中的strs为字符型数组String,StringBuffer和StringBuilder
String不可变，线程安全；StringBuilder不是线程安全的，StringBuffer线程安全
static关键字
静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。静态变量通常用来声明一个类常量，即常量通常被声明为public/private，final和static类型的变量。常量初始化后不可改变。
实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。
非静态成员不能再静态方法中访问
静态内部类
非静态内部类依赖于外部类的实例，而静态内部类不需要。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class OuterClass {
class InnerClass {
}
static class StaticInnerClass {
}
public static void main(String[] args) {
// InnerClass innerClass = new InnerClass();
// 'OuterClass.this' cannot be referenced from a static context
OuterClass outerClass = new OuterClass();
InnerClass innerClass = outerClass.new InnerClass();
StaticInnerClass staticInnerClass = new StaticInnerClass();
}
}
静态内部类不能访问外部类的非静态的变量和方法。
如果想在静态方法中访问非静态变量，那么可以用：但在静态方法以及其他类中，就应该使用完全限定名ObejectReference.VariableName（实例.属性 ）
静态变量可以通过：ClassName.VariableName的方式访问。
1
2
3
4
5
6
7
8
9
10
11
12public class A {
private static int x;
private int y;
public static void func1(){
int a = x;
// int b = y; // Non-static field 'y' cannot be referenced from a static context
// int b = this.y; // 'A.this' cannot be referenced from a static context
int b = new A().y; //这个是可以的
}
}
尽量不要使用public变量
可以使用公有的 getter 和 setter 方法来替换公有字段，这样的话就可以控制对字段的修改行为。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class AccessExample {
public String id;
}
避免这样写，可以用如下方法：
public class AccessExample {
private int id;
public String getId() {
return id + "";
}
public void setId(String id) {
this.id = Integer.valueOf(id);
}
}
泛型
允许在编译时检测非法的类型，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
使用 场景：
写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
使用 Java 泛型的概念，可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。
int，double叫做数据类型，Integer，Double叫做包装类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
这里的E代表一种包装类型，包括Integer，Double，Character。但不能是基本类型比如int,double,char
public class MaximumTest
{
// 比较三个值并返回最大值
public static <T extends Comparable<T>> T maximum(T x, T y, T z)
{
T max = x; // 假设x是初始最大值
if ( y.compareTo( max ) > 0 ){
max = y; //y 更大
}
if ( z.compareTo( max ) > 0 ){
max = z; // 现在 z 更大
}
return max; // 返回最大对象
}
public static void main( String args[] )
{
System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ) );
System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
"apple", "orange", maximum( "pear", "apple", "orange" ) );
}
}
实现了Comparable接口的类可以直接用于比较java从控制台输入字符串
1
2
3
4
5BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String query=br.readLine();
String title=br.readLine();
System.out.println(query);
System.out.println(title);Java中的比较器
新建最大顶堆，新建堆
可以使用优先队列创建
1
2
3
4PriorityQueue<Integer> myres=new PriorityQueue<>((o1,o2)->(o2-o1))
使用优先队列创建链表。这里为什么是大顶堆
o1为前者，o2为后者。如果升序，则o1<o2，后面的函数需要返回-1，如何才能返回-1呢？o1-o2即可
或者(o2-o1)<0时，传入的(o1,o2)中o1放在前面，o2放在后面Arrays.sort(temp,(s1,s2)->(s1+s2).compareTo(s2+s1));
//这里是什么意思？如果s1+s2比s2+s1小，那么compareTo的返回值为-1.传入的s1放在前面，s2放在后面。否则s1放在后面，s2放在前面public int compareTo(Person o){
return this.age-o.age;}
如果升序排序，要求前者this<后者o，函数返回-1class SortByNumber implements Comparator
{ public int compare(Student o1,Student o2){ return o1.getNumber()-o2.getNumber(); }}
int compare(Object o1, Object o2) 返回一个基本类型的整型 ，o1为前者，o2为后者
如果要按照升序排序,则o1 小于o2，函数需要返回-1（负数）。那么如何才能返回-1呢，o1-o2即可1
2
* Java数据结构转换与使用利用已知的数据创建数组：new int[]{1，2，3}
字符串转为字符数组：char[] arr=str.toCharArray();
Java打印数组[]内容：System.out.println(Arrays.toString(arr));
Java对数组[]排序或者Java对Collections排序：Arrays.sort(arr);Collections.sort()函数；前者对数组排序，后者可以对ArrayList排序java的LinkList可以用来创建栈、队列和双向队列
int[][] samecount=new int[A.length][B.length]java创建队列：
Queuequeue=new LinkedList<>();用LinkedList即可创建
java创建栈
Stack
//先将set集合转为Integer型数组
Integer[] temp=allset.toArray(new Integer[] {});
//再将Integer型数组转为int数组
int[] intArray=new int[temp.length];
for (int i=0;i<temp.length;i++){
intArray[i]=temp[i].intValue();
}
//也可以使用toArray()方法直接转为Object对象数组，然后再逐个转为整型数组：
public static int[] SetToInt2(Set
Object[] obj=allset.toArray();//先讲set集合转为Object对象数组（向上转型）
int[] temp=new int[obj.length];
for (int i=0;i<obj.length;i++){
temp[i]=(int)obj[i];//将Object对象数组转为整型数组（强制向下转型）
}
return temp;
}
1
2
* 从控制台一直扫描输入，每输入一行就执行相关运算
Scanner scan=new Scanner(System.in);
while (scan.hasNext()){
int n=scan.nextInt();
int res=getNum(n);
System.out.println(res);
}
1 |
|
java将数组转为List，java.util.Arrays#asList()方法
public static
不能使用基本类型数组作为参数，只能使用相应的包装类型数组。
如：
int[] i ={11,22,33};
List intlist = Arrays.asList(i);
for(Object o:intlist){
System.out.println(o.toString());
}
将不能打印正确结果，因为传入的参数不能是基本类型（byte,short,int,long,float,double,boolean）数组，只能是包装类型。将int换为Integer即可
基本类型与包装类型：
基本类型：int，double，char
包装类型:Integer,Double,Character
基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。
Integer x = 2; // 装箱
int y = x; // 拆箱
1
2
3
4
Java中Array与ArrayList的区别：Array可以包含基本类型和对象类型，ArrayList只能包含对象类型；Array大小是固定的，ArrayList的大小是动态变化的。
数组ArrayList的序列化与反序列化：
ArrayList list = new ArrayList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(list);
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(“test.txt”));
Object e=ois.readObject();
System.out.println(e);
1 |
|
int hash = hash(key);
int i = indexFor(hash, table.length);
1 |
|
java的枚举
编程时要创建常量时，可以使用Java枚举；当然除了枚举，定义private static int var也是可以的。对比上述两种方法，有以下两种区别：
使用static类静态变量定义：打印时只能知道变量的值，无法知道变量的实际含义
使用枚举定义：打印可以知道变量的实际意义，而不只是单单的数字值
下述代码演示了如何创建Java枚举：
1 | public enum Light { |