Java——基础语法

public static void main(String[] args)
	{
		int i=3;
		int s=(i++)+(i++)+(i++);
		System.out.println("s="+s+",i="+i);
		i=3;
		s=(++i)+(++i)+(++i);
		System.out.println("s="+s+",i="+i);
	}
//s=12,i=6
//s=15,i=6

3.2 比较运算符

（比较常见，就不写了...）

3.3 逻辑运算符

运算符	运算
&	与
\|	或
^	异或
！	非
&&	短路与
\|\|	短路或

&&和&的区别：

在判断时，如果前一项为假，&&不会执行后一项，但&会执行后一项。

3.4 三元运算符

（和c一样）

b ? x:y

先计算b，若b为真，则运算结果为x；为假，则为y。

等价于 if-else二分支语句

4. 流程控制

4.1 选择语句

（1）if

public static void main(String[] args)
//程序执行从main开始
{
	double a;
	Scanner input=new Scanner(System.in);
	System.out.print("please input a:");
	a=input.nextDouble();
	if(a>=0 & a<=10)
	{
		System.out.println("a小于10");
	}
	else if(a>10 && a<100)
	{
		System.out.println("a大于10");
	}
	else
	{
		System.out.println("|a|="+(-a));
	}
}

（2）Switch开关语句

public static void main(String[] args)
//程序执行从main开始
{
	char op;
	double a=4;
	double b=3;
	Scanner input=new Scanner(System.in);
	System.out.print("please input a:");
	op=input.next().charAt(0);
	switch(op)
	{
	case '+':
	{
		System.out.println("a+b="+(a+b));
		break;//需要有break跳出循环
	}
	case '-':
	{
		System.out.println("a-b="+(a-b));
		break;
	}
	case '/':
	{
		System.out.println("a/b="+(a/b));
		break;
	}
	case '%':
	{
		System.out.println("a%b="+(a%b));
		break;
	}
	default:
	{
		System.out.println("输入错误！");
	}
	}
}

Switch分支中没有break，则不会跳出继续会向下执行。

4.2 循环控制语句

（1）for语句

/*格式：
for(初始化条件；条件表达式；迭代语句)
{
   循环体语句
}*/

int i,sum=0;
for(i=5;i>=0;i--)
{
   sum=i+sum;
}

（2）while语句

/*格式：
while(条件表达式)
{
   语句块
}
*/
		sum=0;
		i=5;
		while(i>=0)
		{
			sum=sum+i;
			i--;
		}
		System.out.println(sum);
//结果：15

（3）do..while语句

/*格式：
do
{
  语句块
}while(条件表达式);
*/
		do
		{
			sum=sum+i;
			i--;
		}while(i>=0);

do while和while的区别：do while先执行循环体在条件判断，while先执行条件判断再执行循环体

for的执行顺序：表达式1，表达式2（条件判断，若不成立直接跳出），循环体，表达式三

4.3辅助语句

（1）break lable;

（2）continue lable;（跳到指定位置lable（标签））

5. 数组

5.1 创建数组

1. 创建一个空数组：dataType[ ] arrayRefVar=new dataType[arraySize]

过程：使用datatype创建了一个数组-->将新创建的数组

2. 直接赋值创建：dataType[ ] arrayRefVar={value0,value2,...}

5.2 多维数组

1. 声明：

常用：type [ ][ ] arrayName;

2. 创建数组

(1) dataType[ ][ ] arrayRefVar=new dataType[arraySize1][arraySize2]
int [ ][ ]arr=new int [2][3] 
(2) 在声明时，同时初始化
String[][] s={{"北京","天津"},{"上海"}}
注：Java的二维数组是数组的数组，对于二维数组的声明可以只指定第一维的大小，第二维的每个元素可以指定不同的大小

5.3 Arrays类

数组赋值：fill

数组排序：sort（升序）

比较数组：equals（比较数组中的元素值是否相同）

查找数组元素：排序好的可以使用二分法查找

6. String类

6.1 创建字符串

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了

    public static void main(String[] arg) {
        //直接创建
        String a="hello world";
        //键盘输入
        Scanner cin = new Scanner(System.in);
        String b = cin.nextLine();
        System.out.println(b);
        //字符数组
        char[] d1={'h','e','l','l','o'};
        String d=new String(d1);
        System.out.println(d);

    }

6.2 String方法

6.3 StringBuffer类和StringBuilder类

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder s=new StringBuilder();
//添加
s.append("hello...");
System.out.println(s);
//插入
s.insert(5," world");
System.out.println(s);
//删除
s.delete(10,12);
System.out.println(s);


/***
结果：
hello...
hello world...
hello worl..
***/

7. 输入输出函数

（1）输入

1.导入Scanner包

import java.util.Scanner

2.定义Scanner对象

Scanner scanner=new Scanner(System.in);

3.数据输入（nextXXX()表示获取的数据类型）
Scanner sc=new Scanner(System.in); 
//整数类型
int n=sc.nextInt();
sc.nextLine();
//字符类型
String str=sc.nextLine();
//浮点型
double f=sc.nextDouble();
问题：当输入整形时，按下回车表示输入完毕，但接着输入字符型时，会将换行符当做输入内容。

解决方法：1.将字符输入放在前面 2.在字符输入前加上sc.nextLine();

（2）输出

1.println()

格式：System.out.println(msg); // 输出一个字符串, 带换行

注：（）中传递任意数据类型，多个类型使用 “+” 拼接，输出内容后自带换行符。

2.print()

格式：System.out.print(msg); // 输出一个字符串, 不带换行

注：（）中必须要有参数，不像println可以不带参数只表示换行。

3.printf()

格式：System.out.printf(format, msg); // 格式化输出

注：和c语言一样的格式化输出。

%c
单个字符

%d
十进制整数

%f
十进制浮点数

%o
八进制数

%s
字符串

%u
无符号十进制数

%x
十六进制数
%% 输出百分号%

4. 格式化输出

8. Java流、文件和I/O

9. list接口及其实现类

9.1 ArrayList（动态数组）

定义：可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，可以添加或删除元素。

1.创建
import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<数据类型> 对象名 =new ArrayList<数据类型>();　 // 初始化
2.基本方法

（1）添加元素

sites.add("Wa")：添加元素Wa

（2）访问元素

sites.get(n)：访问第n个元素

（3）修改元素

sites.set(2, "Wiki") ：将第二个元素修改为“Wiki”

（4）删除元素

sites.remove(2)：删除第二个元素

（5）计算大小

sites.size()：返回sites的大小

（6）排序

Collections 类提供sort()方法进行排序
import java.util.Collections;  // 引入 Collections 类
Collections.sort(sites);  // 若sites是字符，则按照字母排序
（7）迭代数组列表
 public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        ArrayList<Integer> s=new ArrayList<Integer>();
        s.add(23);
        s.add(21);
        s.add(1);
        s.add(2);
        //排序
        Collections.sort(s);
        //用for来迭代
        for (int i=0;i<s.size();i++)
        {
            System.out.print(s.get(i)+" ");
        }
        System.out.println();
        //for-each迭代
        for (int i :s)
        {
            System.out.print(i+" ");
        }
    }
注：索引都是从0开始

9.2 LinkedList (链表)

与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

1.创建
import java.util.LinkedList;
LinkedList<Integer> s=new LinkedList<Integer>();
2.基本方法

（1）添加元素

在列表头添加：sites.addFirst("Wiki");

在列表尾添加：sites.addLast("Wiki");

（2）移除元素

在列表头移除：sites.removeFirst();

在列表尾移除：sites.removeLast();

（3）获取元素

获取列表头元素：sites.getFirst();

获取尾部元素：sites.getLast();

获取第i个元素：sites.get(i);

（4）计算大小

获取列表的大小：sites.size();

（5）迭代元素
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        LinkedList<Integer> s=new LinkedList<Integer>();
        s.add(23);
        s.add(21);
        s.add(1);
        s.add(2);
        for (int i=0;i<s.size();i++)
        {
            System.out.print(s.get(i)+" ");
        }
    }

10. HashSet

11. HashMap

创建一个HashMap 对象（字典） 1.格式：HashMap<key的数据类型, value的数据类型> 对象名 = new HashMap<key的数据类型, value的数据类型>();
import java.util.HashMap;
HashMap<String, String> Sites = new HashMap<String, String>();

基本方法

1. 添加元素 sites.put()
// 添加键值对
        Sites.put("23", "Google");
        Sites.put("2", "Runoob");
        Sites.put("21", "Taobao");
        Sites.put("12", "Zhihu");
2.访问

（1）sites.get(key)：获得key的值value

（2）sites.keySet()：输出一个所有key的列表

（3）sites.values()：输出一个所有value的列表

3.删除

sites.remove(key) ：删除 key 对应的键值对(key-value)

4.计算大小

sites.size()：输出有多少对key-value