一.编写 Java 程序时,应注意以下几点:
1.大小写敏感:Java 是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的。
2.类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
3.方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
4.源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记 Java 是大小写敏感的),文件名的后缀为 .java。(如果文件名和类名不相同则会导致编译错误)。
5.主方法入口:所有的 Java 程序由 public static void main(String[] args) 方法开始执行
二.对象是根据类创建的。在Java中,使用关键字 new 来创建一个新的对象。创建对象需要以下三步:
声明:声明一个对象,包括对象名称和对象类型。
实例化:使用关键字 new 来创建一个对象。
初始化:使用 new 创建对象时,会调用构造方法初始化对象
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数:name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}
子类是父类的类型,但父类不是子类的类型。
子类的实例可以声明为父类型,但父类的实例不能声明为子类型。
package leetcood.usualtest.t2;
class Vehicle {}
public class Car extends Vehicle {
public static void main(String args[]){
Vehicle v1 = new Vehicle(); //父类型
Vehicle v2 = new Car(); //子类的实例可以声明为父类型
Car c1 = new Car(); // 子类型
// Car c2 = new Vehicle(); //这句会报错,父类型的实例不能声明为子类型 new Vehicle()这是实例; Car 这是声明的类型
//Car(子类)是Vehicle(父类)类型, Vehicle(父类)不是Car(子类)类型
boolean result1 = c1 instanceof Vehicle; // true
boolean result2 = c1 instanceof Car; // true
boolean result3 = v1 instanceof Vehicle; // true
boolean result4 = v1 instanceof Car; // false
boolean result5 = v2 instanceof Vehicle; // true
boolean result6 = v2 instanceof Car; // true
System.out.println(result1);
System.out.println(result2);
System.out.println(result3);
System.out.println(result4);
System.out.println(result5);
System.out.println(result6);
}
}
三.if…else if…else 语句
if 语句至多有 1 个 else 语句,else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。
四.java中的自动装箱与拆箱
/**
* @author Dale
* java中的自动装箱与拆箱
* 简单一点说,装箱就是自动将基本数据类型转换为包装器类型;拆箱就是自动将包装器类型转换为基本数据类型。
*/
public class Number {
public static void main(String[] args) {
/**
Integer i1 = 128; // 装箱,相当于 Integer.valueOf(128);
int t = i1; //相当于 i1.intValue() 拆箱
System.out.println(t);
*/
/**
对于–128到127(默认是127)之间的值,被装箱后,会被放在内存里进行重用
但是如果超出了这个值,系统会重新new 一个对象
*/
Integer i1 = 200;
Integer i2 = 200;
/**
注意 == 与 equals的区别
== 它比较的是对象的地址
equals 比较的是对象的内容
*/
if(i1==i2) {
System.out.println("true");
} else {
System.out.println("false");
}
}
}
Java 中 int 和 Integer 的区别:
- int 是基本数据类型,int 变量存储的是数值。Integer 是引用类型,实际是一个对象,Integer 存储的是引用对象的地址。
Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false
因为 new 生成的是两个对象,其内存地址不同。
3.int 和 Integer 所占内存比较:
Integer 对象会占用更多的内存。Integer 是一个对象,需要存储对象的元数据。但是 int 是一个原始类型的数据,所以占用的空间更少。
- 非 new 生成的 Integer 变量与 new Integer() 生成的变量比较,结果为 false。
/**
* 比较非new生成的Integer变量与new生成的Integer变量
*/
public class Test {
public static void main(String[] args) {
Integer i= new Integer(200);
Integer j = 200;
System.out.print(i == j);
//输出:false
}
}
-
两个非 new 生成的 Integer 对象进行比较,如果两个变量的值在区间 [-128,127] 之间,比较结果为 true;否则,结果为 false。
java 在编译 Integer i1 = 127 时,会翻译成 Integer i1 = Integer.valueOf(127)。 -
Integer 变量(无论是否是 new 生成的)与 int 变量比较,只要两个变量的值是相等的,结果都为 true。
/**
* 比较Integer变量与int变量
*/
public class Test {
public static void main(String[] args) {
Integer i1 = 200;
Integer i2 = new Integer(200);
int j = 200;
System.out.println(i1 == j);//输出:true
System.out.println(i2 == j);//输出:true
}
}
包装类 Integer 变量在与基本数据类型 int 变量比较时,Integer 会自动拆包装为 int,然后进行比较,实际上就是两个 int 变量进行比较,值相等,所以为 true。
五.Java Character 类
Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值
public class UpperLowerCase {
/*
* 利用Character类提取字符串中的大写字母和小写字母
* @auther Anthony-Z
*/
public static void main(String[] args) {
String sr1 = "I Like JAVA ! I learn Java everyday.";
String sr2 = "";
String sr3 = "";
for (int i = 0; i < sr1.length(); i++) {//获取字符串的长度用的是length();
if(Character.isUpperCase(sr1.charAt(i))){//先将String类型的字符串转换成char类型 再获取每一个字符元素,用charAt(i)实现
sr2 += sr1.charAt(i) + " ";//提取大写字母
}
if(Character.isLowerCase(sr1.charAt(i))){
sr3 += sr1.charAt(i) + " ";//提取小写字母
}
}
System.out.println("大写字母有:" + sr2);
System.out.println("小写字母有:" + sr3);
}
}
六.Java String类,及数组类
String 类是不可改变的解析,例如:
String s = "Google";
System.out.println("s = " + s);
s = "Runoob";
System.out.println("s = " + s);
输出结果为:
Google
Runoob
从结果上看是改变了,但为什么门说String对象是不可变的呢?
原因在于实例中的 s 只是一个 String 对象的引用,并不是对象本身,当执行 s = “Runoob”; 创建了一个新的对象 “Runoob”,而原来的 “Google” 还存在于内存中。
Java 中 StringBuffer 和 String 是有一定的区别的,首先,String 是被 final 修饰的,他的长度是不可变的,就算调用 String 的 concat 方法,那也是把字符串拼接起来并重新创建一个对象,把拼接后的 String 的值赋给新创建的对象,而 StringBuffer 的长度是可变的,调用StringBuffer 的 append 方法,来改变 StringBuffer 的长度,并且,相比较于 StringBuffer,String 一旦发生长度变化,是非常耗费内存的!
String 长度大小不可变
StringBuffer 和 StringBuilder 长度可变
StringBuffer 线程安全 StringBuilder 线程不安全
StringBuilder 速度快
java.util.Arrays类能方便地操作数组,它提供的所有方法都是静态的。具有以下功能:
给数组赋值:通过fill方法。
对数组排序:通过sort方法,按升序。
比较数组:通过equals方法比较数组中元素值是否相等。
查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class TestArrays {
public static void output(int[] array) {
if (array != null) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
System.out.println();
}
public static void main(String[] args) {
int[] array = new int[5];
// 填充数组
Arrays.fill(array, 5);
System.out.println("填充数组:Arrays.fill(array, 5):");
TestArrays.output(array);
// 将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.println("将数组的第2和第3个元素赋值为8:Arrays.fill(array, 2, 4, 8):");
TestArrays.output(array);
int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
// 对数组的第2个到第6个进行排序进行排序
Arrays.sort(array1, 2, 7);
System.out.println("对数组的第2个到第6个元素进行排序进行排序:Arrays.sort(array,2,7):");
TestArrays.output(array1);
// 对整个数组进行排序
Arrays.sort(array1);
System.out.println("对整个数组进行排序:Arrays.sort(array1):");
TestArrays.output(array1);
// 比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" + Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" + Arrays.equals(array1, array2));
// 使用二分搜索算法查找指定元素所在的下标(必须是排序好的,否则结果不正确)
Arrays.sort(array1);
System.out.println("元素3在array1中的位置:Arrays.binarySearch(array1, 3):" + "\n" + Arrays.binarySearch(array1, 3));
// 如果不存在就返回负数
System.out.println("元素9在array1中的位置:Arrays.binarySearch(array1, 9):" + "\n" + Arrays.binarySearch(array1, 9));
}
}
输出结果:
填充数组:Arrays.fill(array, 5):
5 5 5 5 5
将数组的第2和第3个元素赋值为8:Arrays.fill(array, 2, 4, 8):
5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序:Arrays.sort(array,2,7):
7 8 2 3 3 6 12 5 4
对整个数组进行排序:Arrays.sort(array1):
2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):
true
元素3在array1中的位置:Arrays.binarySearch(array1, 3):
1
元素9在array1中的位置:Arrays.binarySearch(array1, 9):
-9
能对整体操作,就能对部分操作。
七.方法
重载就是同样的一个方法能够根据输入数据的不同,做出不同的处理,简单的说能够随机应变,根据不同的数据来处理。
重写就是当子类继承自父类的相同方法,输入数据一样,但要做出有别于父类的响应时,你就要覆盖父类方法
重载是同样的一个方法写多次变量修饰符不一样,当调用方法时,会自动判断给入数的类型,选取其中符合的方法。
public class Overloading {
private static int i = 1;
private static double l = 3.1415;
private static String k = "我是栗子";
//参数类型不同
public void test(int a){
System.out.println("你输入了整数:"+a);
}
public void test(double a){
System.out.println("你输入了浮点数:"+a);
}
public void test(String a){
System.out.println("你输入了字符串:"+a);
}
public static void main(String[] args){
Overloading lizi = new Overloading();
lizi.test(i);
lizi.test(l);
lizi.test(k);
}
}
输出结果:
你输入了整数:1
你输入了浮点数:3.1415
你输入了字符串:我是栗子
八.java集合框架
从上面的集合框架图可以看到,Java 集合框架主要包括两种类型的容器,一种是集合(Collection),存储一个元素集合,另一种是图(Map),存储键/值对映射。Collection 接口又有 3 种子类型,List、Set 和 Queue,再下面是一些抽象类,最后是具体实现类,常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
集合框架体系如图所示
Java 集合框架提供了一套性能优良,使用方便的接口和类,java集合框架位于java.util包中, 所以当使用集合框架的时候需要进行导包。
集合接口
Set和List的区别
-
Set 接口实例存储的是无序的,不重复的数据。List 接口实例存储的是有序的,可以重复的元素。
-
Set检索效率低下,删除和插入效率高,插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
-
List和数组类似,可以动态增长,根据实际存储的数据的长度自动增长List的长度。查找元素效率高,插入删除效率低,因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
遍历 ArrayList
import java.util.*;
public class Test{
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");
//第一种遍历方法使用 For-Each 遍历 List
for (String str : list) { //也可以改写 for(int i=0;i<list.size();i++) 这种形式
System.out.println(str);
}
//第二种遍历,把链表变为数组相关的内容进行遍历
String[] strArray=new String[list.size()];
list.toArray(strArray);
for(int i=0;i<strArray.length;i++) //这里也可以改写为 for(String str:strArray) 这种形式
{
System.out.println(strArray[i]);
}
//第三种遍历 使用迭代器进行相关遍历
Iterator<String> ite=list.iterator();
while(ite.hasNext())//判断下一个元素之后有值
{
System.out.println(ite.next());
}
}
}
遍历 Map
import java.util.*;
public class Test{
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第一种:普遍使用,二次取值
System.out.println("通过Map.keySet遍历key和value:");
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}
//第二种
System.out.println("通过Map.entrySet使用iterator遍历key和value:");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第三种:推荐,尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第四种
System.out.println("通过Map.values()遍历所有的value,但不能遍历key");
for (String v : map.values()) {
System.out.println("value= " + v);
}
}
}
ArrayList 和 LinkedList 的区别
ArrayList 是 List 接口的一种实现,它是使用数组来实现的。
LinkedList 是 List 接口的一种实现,它是使用链表来实现的。
ArrayList 遍历和查找元素比较快。LinkedList 遍历和查找元素比较慢。
ArrayList 添加、删除元素比较慢。LinkedList 添加、删除元素比较快。
有关于 map.entrySet() 和 keySet():
1、如果遍历 hashMap() 时 entrySet() 方法是将 key 和 value 全部取出来,所以性能开销是可以预计的, 而 keySet() 方法进行遍历的时候是根据取出的 key 值去查询对应的 value 值, 所以如果 key 值是比较简单的结构(如 1,2,3…)的话性能消耗上是比 entrySet() 方法低, 但随着 key 值得复杂度提高 entrySet() 的优势就会显露出来。
2、综合比较在只遍历 key 的时候使用 keySet(), 在只遍历 value 的是使用 values() 方法, 在遍历 key-value 的时候使用 entrySet() 是比较合理的选择。
3、如果遍历 TreeMap 的时候, 不同于 HashMap 在遍历 ThreeMap 的 key-value 时候务必使用 entrySet() 它要远远高于其他两个的性能, 同样只遍历 key 的时候使用 keySet(), 在只遍历 value 的是使用 values() 方法对于 TreeMap 也同样适用。