Java基础语法学习

---

title: Java基础语法学习
date: 2020-01-31 20:15:02
tags: Java学习

Java基础学习

求公约数辗转相除法

        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
		int b = in.nextInt();
		int oa = a;
		int ob = b;
		while(b != 0)
		{
			int r = a % b;
			System.out.println(a+","+b+","+r);
			a = b;
			b = r;
		}
		System.out.println(oa+"和"+ob+"的最大公约数是"+a);

数组

数组是一种容器（放东西的东西）特点是：

①其中所有的元素具有相同的数据类型

②一旦创建不能改变大小

定义数组遍历

<类型>[] <名字> = new <类型>[元素个数]
· int[] grades = new int[100];
` double[] averages = new double[20];

元素的个数必须为整数

元素个数必须给出

元素个数可以为变量

有效的下标 最小下标为0最大下标为数组元素个数-1

但是编译器不检查 但是运行的时候会越界。

写一个用户输入数字的平均值 输出所有大于平均数的数字

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		double sum = 0;
		int cnt = 0;
		cnt = in.nextInt();
		if(cnt > 0)
		{
			int[] numbers = new int[cnt];
			for(int i = 0; i < cnt; i++)
			{
				numbers[i] = in.nextInt();
				sum += numbers[i];
			}
			double average = sum/cnt;
			for(int i = 0; i < numbers.length; i++)	//遍历数组
			{
				if(numbers[i] > average)
				{
					System.out.println(numbers[i]);	//使用数组中的元素
				}
			}
			System.out.println(sum/cnt);
		}
	}

length 函数用于计算数组的长度

使得有可扩展性 length与cnt无关

投票统计

写一个程序 统计每一种【0-9】中数字出现的次数

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int x;
		int [] numbers = new int[10];
		for(int i = 0; i < numbers.length; i++)
		{
			System.out.println(numbers[i]);
		}
		x = in.nextInt();
		while(x != -1)
		{
			if(x >= 0 && x <= 9)
			{
				numbers[x]++;
			}
			x = in.nextInt();
		}
		for(int i = 0; i < numbers.length; i++)
		{
			System.out.println(i+":"+numbers[i]);
		}
	}

输出

0
0
0
0
0
0
0
0
0
0
1 1 2 3 3 3 4 -1
0:0
1:2
2:1
3:3
4:1
5:0
6:0
7:0
8:0
9:0

new创建的数组在设置的时候默认初始化为全0数组

int[] scores = {111, 2222, 33333, 44444, 5555, 6666, 78};

初始化的时候不需要做个数的设置

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] scores = {87, 98, 66, 410, 8798, 454};
		System.out.println(scores.length);
		for(int i = 0; i < scores.length; i++) 
		{
			System.out.println(scores[i]+" ");
		}
	}

输出

6
87 
98 
66 
410 
8798 
454 

数组赋值问题

数组变量和普通变量不同

普通变量为数据的所有者 变量中有数据

数据变量只是数据的管理者，数据放在new制造数组当中 只是数组变量指向了那个数据。

int[] b=a; 为b去管理a所管理的数组 所以 a和b两个数组变量管理同一个数组。所以有：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] a = new int[10];
		a[0] = 5;
		int[] b = a;
		System.out.println(a[0] + " " + b[0]);
		b[0] = 16;
		System.out.println(a[0] + " " + b[0]);
	}

输出

5 5
16 16

a和b指向同一个地方所以改变b的时候a指向的数组(为同一个数组)也被改变

数组变量
数组变量是数组的管理者 而不是数组本身
数组必须是创建出来以后交给数组变量来管理
数组变量之间的赋值是管理权限的赋予
数组变量之间的比较是判断是否管理同一个数组

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] a = {1, 2, 3, 4, 5};
		int[] b = {1, 2, 3, 4, 5};
		System.out.println(a==b);
	}

输出

false

与数组内容无关 是看创建的数组是否是同一个数组

复制数组
必须遍历数组将每一个元素逐一拷贝

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] a = {1, 2, 3, 4, 5};
		int[] b = new int[a.length];
		for(int i = 0; i < b.length; i++)
		{
			b[i] = a[i];
		}
		for(int i = 0; i < b.length; i++)
		{
			System.out.println(b[i]);
		}
		System.out.println(a==b);
	}

for each循环 不可以修改数组 但是可以读出所有的元素

for(<类型(数组元素类型)><变量>:<数组>)
{
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] data = {1, 123, 4, 2, 12, 11, 34, 55};
		int x = in.nextInt();
		int loc = -1;
		boolean found = false;
		for(int i = 0; i < data.length; i++)
		{
			if(x == data[i])
			{
				loc = i;
				break;
			}
		}
		for(int k : data)	//for-each循环 对于data数组中的每一个元素 赋值给k
		{
			k = 0;
		}
		for(int k : data)
		{
			System.out.println(k);
		}
		if(loc > -1)
		{
			System.out.println(x+"是第"+(loc+1)+"个");	//(loc+1)加括号是为了表示不是字符串的链接 而是做加法+1
		}
		else
		{
			System.out.println(x+"不在其中");
		}
	}

输入：55
输出：
1
123
4
2
12
11
34
55
55是第8个

生成素数表

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int[] primes = new int[50];
		primes[0] = 2;
		int cnt = 1;	//目前有一个 下一个放在primes[1]
		MAIN_LOOP:
		for(int x = 3; cnt < 50; x++)
		{
			for(int i = 0; i < cnt; i++)
			{
				if(x % primes[i] == 0)
				{
					continue MAIN_LOOP;
				}
			}
			primes[cnt++] = x;
		}
		for( int k : primes )
		{
			System.out.print(k+" ");
		}
		
	}

50以内素数

另外一种打表法

构造n以内不含n的素数表

1.创建prime为boolean[n] 初始化其所有元素为true prime[x]为true为x为素数

2.令x=2

3.如果x为速速则对(i=2;i*i<n;i++)

令prime[i*x]=false

4.令x++ 如果x<n重复3否则结束

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		boolean[] isPrime = new boolean[100];
		for(int i = 0; i < isPrime.length; i++)
		{
			isPrime[i] = true;
		}
		for(int i = 2; i < isPrime.length; i++)
		{
			if(isPrime[i])
			{
				for(int k = 2; i*k < isPrime.length; k++)
				{
					isPrime[i*k] = false;
				}
			}
		}
		for(int i = 2; i < isPrime.length; i++)
		{
			if(isPrime[i])
			{
				System.out.print(i+" ");
			}
		}
	}

二维数组的初始化

int[][] a = {
	{1, 2, 3, 4},
	{1, 2, 3},
}
·编译器来数数
·每一个{}逗号分隔
·最后的逗号可以存在 古老的传统
·如果省略的元素自动补0

String

new = 创建

String s = new String(“a string”);

创建一个String的对象

用"a string"初始化这个对象

创建管理这个对象的变量s

让s管理这个对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lmVxoVpI-1580663546298)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201105355406.png)]

初始化字符串变量

String s = “hello”;

编译器帮你创建一个String类的对象交给s来管理

字符串的连接
用+可以连接两个字符串

“hello”+“world”—>“helloworld”

这个 +的一边为字符串另一边不是的时候会将另一边表达为字符串然后连接

"I’m "+“18”–>“I’m 18”

1+2+“age”—>“3age”

“age”+1+2—>“age12”

public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s = new String("Hello");
		System.out.println(s+12+24);
		System.out.println(s+(12+24));
	}

输出

Hello1224
Hello36

输入字符串

in.next();读入一个单词 单词结束的标志为空格(包括空格 tab 和换行)

in.nextLine();读入一整行

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s;	//不能直接输出
		s = in.nextLine();
		System.out.println(s);
		s = in.next();
		System.out.println(s);
	}

输入输出

This is a test.
This is a test.
This is a test.
This

比较两个String

String只比较内容 不比较对象是否相同使用.equal

if(input == "bye") {//比较是否同一个对象
	...	
}
if(input.equals("bye")) {//单纯比较内容是否相同
	...	
}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s;
		s = in.next();
		System.out.println();
		System.out.println(s=="bye");
		System.out.println(s.equals("bye"));
	}

输入
bye
输出
false
true

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Voj2qP6t-1580663546301)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201110635070.png)]

只是内容相同 对象不同 person1 == person2 为false

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZnjWGTU-1580663546304)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201110710227.png)]

只有对象是同一个的时候 person1 == person2 为true

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iK5FGjE4-1580663546305)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201110744798.png)]

equal为比较是否为相同内容 与是否为同一个东西不同。

字符串操作

两个字符串可以比较大小

s1.compareTo(s2)

如果s1比s2小，那么结果为负的；如果s1和s2相等那么结果为0；如果s1比s2大那么结果为正的

compareToIgnoreCase 可以不区分大小写的来比较大小

public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s1 = "abc";
		String s2 = "ab";
		System.out.println(s1.compareTo(s2));
	}

大于结果为1

相同结果为0

小于结果为-1

length()获取String的长度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iv8cqnDr-1580663546306)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201124843263.png)]

public static void main(String[] args) {
	Scanner in = new Scanner(System.in);
	String s1 = "汉字";
	for(int i = 0; i < s1.length(); i++)
	{
		System.out.println(s1.charAt(i));
	}
}

substring

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s1 = "0123456789汉字";
		System.out.println(s1.substring(2));
		System.out.println(s1.substring(2, 4));
	}

23456789汉字
23

此处注意substring与c++一样4为结束的后一个 所以不是234而是23

寻找字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tv4DC0sZ-1580663546308)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201125305958.png)]

public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s1 = "0123A563789汉字";
		int loc = s1.indexOf('3');
		System.out.println(s1.indexOf('3', loc+1));	//从loc+1开始去找
		System.out.println(s1.indexOf("A56"));
		
	}

7
4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vVWuX02B-1580663546309)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201125738308.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AOqSPMXH-1580663546313)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201125755891.png)]

public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s1 = "abcd";
		String s2 = s1.toUpperCase();
		System.out.println(s1);
		System.out.println(s2);
	}

abcd
ABCD

String字符串本身不修改 只是制造了一个新的字符串变量 需要交给一个新的字符串去做记录。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clvi4iZf-1580663546315)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201130053160.png)]

Math

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println(Math.abs(-12));	//绝对值
		System.out.println(Math.round(10.645));	//四舍五入
		System.out.println(Math.random()*100);	//01之间随机小数
		System.out.println(Math.pow(2, 3.2));	//乘方
	}

输出

12
11
66.67205833706238
9.18958683997628

函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-emcdZita-1580663546317)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201131155068.png)]

.带()的 s可以操作的一个函数。

.可以读为的

public static boolean isPrime(int i)
	{
		boolean isPrime = true;
		for(int k = 2; k < i; k++)
		{
			if(i%k == 0)
			{
				isPrime = false;
				break;
			}
		}
		return isPrime;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int m = in.nextInt();
		int n = in.nextInt();
		if( m == 1) m = 2;
		int cnt = 0;
		int sum = 0;
		for(int i = m; i <= n; i++)
		{
			if(isPrime(i))
			{
				cnt++;
				sum+=i;
			}
		}
		System.out.println("在"+m+"和"+n+"之间有"+cnt+"个素数 总和为"+sum);
	}

2 20
在2和20之间有8个素数 总和为77

public static void sum(int a, int b)
	{
		int i;
		int sum;
		sum = 0;
		for(i = a; i <= b; i++)
		{
			sum += i;
		}
		System.out.println(a+"到"+b+"的和是"+sum);
	}
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		sum(1,10);
		sum(20,30);
		sum(35,40);
	}

1到10的和是55
20到30的和是275
35到40的和是225

函数是一块diamante 接受0个或者多个参数 做一件事情 并且返回零个或者多个参数，并且返回0个或者一个值。

函数定义

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tmio4Jfw-1580663546318)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201132449146.png)]

调用函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3yeJc9Sc-1580663546320)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201132722247.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZbJq8eoX-1580663546322)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201133050031.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g2yWUO2A-1580663546323)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201133131253.png)]

如果 返回值 则函数前面要有返回类型 此处为Int

在函数中要有return返回值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CUqQIxEj-1580663546325)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201133507112.png)]

如果函数有返回值 必须使用带值的return

否则我们直接使用不带值的return即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KQyDKgVc-1580663546327)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201134149255.png)]

java语言中 调用函数只是值传递 只能传值给函数 函数对值的修改 不对主函数有任何影响

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ojEZnT5W-1580663546332)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201134650368.png)]

函数swap中ab为参数 a b保持不变为5 6

而传入参数的为值 参数改变的时候调入的值不改变 只是值赋值给了参数

参数类型为字符串的时候也是

但是当参数传的是对象的时候是保持一致的 如数组变量作为对象管理者当元素在函数中操作的时候就会使用管理者对被管理的数组做变化

	public static void swap(int[] a, int[] b)	//仅仅为值传递
	{
		int t;
		for(int i = 0; i < a.length; i++) {
			t = a[i];
			a[i] = b[i];
			b[i] = t;	
		}
		
	}
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int[] a = {1,2,3,4,5};
		int[] b = {5,6,7,8,9};
		swap(a,b);
		for(int i = 0; i < a.length; i++) {
			System.out.println("a["+i+"]="+a[i]+";b["+i+"]="+b[i]);
		}
	}	

a[0]=5;b[0]=1
a[1]=6;b[1]=2
a[2]=7;b[2]=3
a[3]=8;b[3]=4
a[4]=9;b[4]=5

发生了交换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vATXmUq9-1580663546334)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201135639681.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4a6G29F6-1580663546335)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201140652060.png)]

函数传递参数调试的时候这边stepinto后都会有一个单独的空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zGMYPAsv-1580663546336)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201140723012.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zHQu7PWw-1580663546340)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201140738747.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DBbkLBDZ-1580663546341)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201140907928.png)]

本地变量的生存是在它定义的那一层大括号 在大括号{}内生存 脱离了{}就失效了

在同一个大阔内不可以重复定义变量

在大范围内定义的变量在小范围内不可以重复定义

此层函数的参数也是本地变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7eTYLXsX-1580663546342)(C:\Users\36987\AppData\Roaming\Typora\typora-user-images\image-20200201141642572.png)]