Java 基础语法_蓝桥杯

文章目录

• • 1 主类名必须是Main
  • 2 输入输出
  • • 2.1 输入
    • 2.2 输出
  • 3 编程规范和常用数据类型
  • • 3.1 简介
    • 3.2 `Java`常见数据类型
    • 3.3 数组
    • 3.4 `String`

1 主类名必须是Main

public class Main {
	public static void main(String[] args) {
		System.out.println("Helo world!");
	}
}

2 输入输出

2.1 输入

2.1.1 使用Scanner类的.nextXXX()方法:

new一个Scanner类

Scanner in = new Scanner(System.in);//new一个Scanner类

2.1.2 实数输入

int a = in.nextInt();// 整数输入
long b = in.nextLong();// 长整数输入
short c = in.nextShort();// 短整数输入
double e = in.nextDouble();// 双精度浮点输入
float f = in.nextFloat();// 单精度浮点输入

2.1.3 字符串输入

String f = in.next();//输入一个字符串
char g =  in.next().charAt(0);//输入一个字符串 选择第一个赋值给g，从而实现char的输入
String s[] = in.nextLine().split(" "); // 使用split通过空格分割读入的一行字符串，存在s中

while (in.hasNext()) {
	String s2[] = in.nextLine().split(" ");
	for(String i : s2) {
		System.out.println(i);
	}
}

2.1.4 next()和nextLine()的区别

String s1 = in.next();//输入一个字符串 遇到空格结束相当于 cin 和 scanf
String s2 = in.nextLine();//输入一行字符串，可接收空格相当于cin.getline() 和 gets()

2.1.5 hasNext()方法

hasNext()方法可以作为多组输入，hasNext()的返回值是boolean值，作用是当在缓冲区内扫描到字符时，会返回true， 否则会发生阻塞，等待数据输入。

所以hasNext()是不会返回false的

所以遇到多组输入时，可以使用 while(in.hasNext()){}相当于 while(~scanf()){}

while(in.hasNext()) {
	int A = in.nextInt();
	int B = in.nextInt();
	System.out.printf("%d\n",A+B);
}

int A,B;
while(~scanf("%d%d",&A,&B)){
    printf("%d\n",A+B);
}

!!!注意和nextXXX()方法类似,hasNextXXX()也有针对不同类型变量的方法:

hasNext() // 判断缓存区中还有没有数据，有返回true, 否则等待输入。
hasNextInt() // 判断输入的是不是int型的数据,是的话返回true 否则继续扫描缓冲区，或者等待输入。
hasNextDouble() // 判断输入的是不是double型的数据,是的话返回true 否则继续扫描缓冲区，或者等待输入。
...

2.2 输出

Java中往控制台输出的几种常用函数：

2.2.1 printf()方法

System.out.printf(); 和printf一样。 可使用格式控制符进行格式化输出。

int A = in.nextInt();
int B = in.nextInt();
System.out.printf("%d\n", A + B);

2.2.2 print()方法

System.out.print();不能使用格式控制符进行格式化输出，仅输出变量。

int A = in.nextInt();
int B = in.nextInt();
System.out.print(A + B);

2.2.3 println()方法

System.out.println();不能使用格式控制符进行格式化输出，仅输出变量，但会自动输出一个换行。

int A = in.nextInt();
int B = in.nextInt();
System.out.print(A + B);

3 编程规范和常用数据类型

3.1 简介

• Java是纯面向对象语言，所有的程序都要定义在类中，类中只能包含成员变量，成员函数，以及代码块。
• 不能在类体内直接出现其他执行性语句。
• Java程序从和C/C++一样都从main函数开始执行。
• Java中一个Java文件中只能至多包含一个public class 并且当有public clas类时 main函数只能定义在该类中。
• xxx.java 文件的文件名必须必须与main函数所在类的类名相同 。

3.1.1 Java中main函数的定义

public static void main(String[] args){....}

如：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
//		System.out.println("Helo world!");
		Scanner in = new Scanner(System.in);// new一个Scanner类
		while (in.hasNext()) {
			String s2[] = in.nextLine().split(" ");
			for (String i : s2) {
				System.out.println(i);
			}
		}
	}
}

3.2 Java常见数据类型

int float double long char boolean byte

常见类型定义方式：

int a;
float b;
double c;
boolean f = true;

3.3 数组

3.3.1 定义

int a[] = new int[100];

或者

int a[];  
a = new int[100];

3.3.2 初始化

int a[] = {1, 2, 3, 4};

或者

Arrays.fill(a,x); //将a内的每个元素赋值为x

int a[] = new int[10];
Arrays.fill(a, 1);
for(int x:a) {
	System.out.println(x);
}

3.3.3 数组的拷贝

1. clone()

int a[] = new int[10];
int b[] = new int[10];
Arrays.fill(b, 1);
a = b.clone(); // 将b数组的值拷贝给a数组
for(int x:a) {
	System.out.println(x);
}

2. System.arraycopy

//System.arraycopy(Object a, int begin_a, Object b, int begin_b, int length);
//从a复制到b，复制从a数组指定的位置begin_a开始，到begin_a+length-1结束。放置从b的begin_b开始，到begin_b+length-1结束。 
int[] a = {1, 2, 3, 4};
int[] b = new int[10];
System.arraycopy(a, 0, b, 0, 3);
for(int i = 0; i < 4; i++){
    System.out.println(b[i]);
}
/*
输出：
1
2
3
0
*/

3. Arrays.copyOf

//Arrays.copyOf(int[] a, int length);
//从a数组的第一个元素开始复制，复制length个元素。
int[] a = {1, 2, 3, 4};
int[] b = new int[10];
b = Arrays.copyOf(a, 4);
System.arraycopy(a, 0, b, 0, 3);
for(int i = 0; i < 4; i++){
    System.out.println(b[i]);
}
/*
输出：
1
2
3
4
*/

4. Arrays.copyOfRange

//Arrays.copyOfRange(int[] a, int begin, int to);
//从a数组begin开始复制，到to-1位置结束。
int[] a = {1, 2, 3, 4};
int[] b = new int[10];
b = Arrays.copyOfRange(a, 0, 4);
for(int i = 0; i < 4; i++){
    System.out.println(b[i]);
}
/*
输出：
1
2
3
4
*/

3.4 String

3.4.1 String的创建

1.String 定义方式形如： String s1 = "qwq";

2.因为String是一个类， 所以也可以通过构造函数初始化， 形如 String s2 = new String("orz");

• 注意， 通过第一种方式创建字符串对象，内存分配在“常量池” 中。在常量池中数据是共享的, 当存在qwq这个常量时，如果再 String s2 = "orz"； 时，此时JVM不会创建新的字符串对象，而是会让s2指向qwq这个常量的地址，也就是说s1和s2的内存地址是相同的。
• 对于第二种方式，每创建一个字符串对象，都会在堆区重新开辟一个空间保存字符串常量。

3.4.2 String的比较

1. ==， != ：

   == ， != 判断的是两个字符串地址是否相等。

   前面已经说过，两个直接用=赋值的字符串对象，如果字符串常量相同则地址相同。

   所以：

     String s1 = "qwq"; 
     String s2 = "qwq"；   
     s1 == s2   // true
    
     String s1 = new String("qwq"); 
     String s2 = new String("qwq");   
     s1 == s2 // false 
   

2. s1.equals(s2);

   //equals()方法是直接比较两个字符串对象的内容，相等返回 true，否则返回false
    String s1 = new String("qwq"); 
    String s2 = new String("qwq");   
    s1.equals(s2); //true
   

   !!!所以判断字符串内容是否相同要用 equals 方法而不能直接用 == 。切记，！！！

3.4.3 String对象的遍历

在java中String不可直接通过索引或者说下标遍历，而要先转化为字符数组或者使用charAt()方法。

String s1 = "123456";
char[] s2 = s1.toCharArray();
for(int i = 0; i < s2.length; i++){ //注意这里的length没有括号！！！
    System.out.println(s2[i]);
}

或者使用增强的for遍历:

String s1 = "123456";
for (char ch : s1.toCharArray()) {
	System.out.println(ch);
}

Java String类还有很多方法，及其强大，由于篇幅这里就不多讲了，详细参考：别人的。