java基础 day06-数组递归等练习题，选择、冒泡排序，创建对象对应的jvm内存结构，空指针异常，java中String类的常用方法

java基础题

1、从控制台输入两个集合，求交集，并将交集中元素按照从高到低出现的顺序输出

package javaproject0316;

import java.util.*;
public class Test1 {
	public static void main(String[] args) {

		System.out.println("从键盘上输入整数a,b集合的值并用空格隔开：");
		Scanner scan = new Scanner(System.in);
		String st = scan.nextLine();
		String[] str = st.split(" ");
		int[] a = new int[str.length];
		for (int i = 0; i < str.length; i++) {
			a[i] = Integer.parseInt(str[i]);
		}
		Scanner scan1 = new Scanner(System.in);
		String st1 = scan.nextLine();
		String[] str1 = st1.split(" ");
		int[] b = new int[str1.length];
		for (int i = 0; i < str1.length; i++) {
			b[i] = Integer.parseInt(str1[i]);
		}
		scan.close();
		scan1.close();
		System.out.print("集合交集为：");
		// 用c来存储a，b集合的交集，大小分配为a，b集合中较大的一个。
		int num = Math.max(a.length, b.length);
		int[] c = new int[num];
		// 外循环，对a集合遍历
		for (int i = 0; i < a.length; i++) {
			// 内循环，对b集合遍历
			for (int j = 0; j < b.length; j++) {
				/*
				 * 如果两集合存在相同元素，那么将该元素作为新集合的下标，同时自增 既将a[i]的值作为下标，在集合c的对应位置上标志出相同元素的值
				 * 此时，集合c中下标标志出的为交集的元素 集合c中的数值是，比较过程中集合a和集合b中元素相等的次数
				 */
				if (a[i] == b[j]) {
					c[a[i]]++;
				}
			}
		}
		// 下标元素标志出了相同元素的值，此时若不为0 ，证明此处被相同元素标记
		for (int i = 0; i < c.length; i++) {
			if (c[i] != 0) {
				System.out.print(i + " ");
			}
		}
		System.out.println();
		System.out.print("重复次数从高到低为：");

		for (int i = 0; i < c.length; i++) {
			// 每次循环从集合c的第一个元素开始.
			int max = c[0];
			// 内循环，遍历集合c的下标
			for (int j = 0; j < c.length; j++) {
				// 用max来找集合c中的最大值，
				if (c[j] > c[max]) {
					max = j;
				}
			}
			// 如果a与b存在交集，那么集合c（其值保存了相同元素被比较的次数）中存在不为0的值，该值越大，证明a，b集合中该元素越多
			if (c[max] != 0) {
				System.out.print(max + " ");
				// 输出最大值后，应将目前最大值元素置0，方便下一次寻找次大值
				c[max] = 0;
			}
		}

	}
}

package javaproject0316;

import java.util.Arrays;


public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = { 1, 2, 8, 3, 1, 3, 2 };
		int[] b = { 1, 2, 3, 5, 3, 5, 3, 2, 1 };
		int num = Math.max(a.length, b.length);
		int[] c = new int[num];
		int point = 0;

		System.out.print("输出的交集为：");
		for (int i = 0; i < a.length; i++) {// 遍历a集合
			boolean flag = false;//表示未处理过
			for (int k = 0; k < i; k++) {
				if (a[i] == a[k]) {
					flag = true;
					break;
				}
			}
			if (flag) {
				continue;
			}

			for (int j = 0; j < b.length; j++) // 遍历b集合{
				if (a[i] == b[j]) {
					c[point++] = a[i];// point中记录了出现的频率
					break;
				}
		}
		for (int i = 0; i < point; i++) {
			System.out.print(c[i] + " ");
		}
		System.out.println();
		System.out.print("输出的交集按照出现频率：");
		
		// 问题2：按出现频率排序
		int[] count = new int[point];
		// 遍历a中的元素
		for (int i = 0; i < point; i++) {
			for (int j = 0; j < a.length; j++) {
				if (c[i] == a[j]) {
					count[i]++;
				}
			}
			// 判断c[i]在b中出现了多少次
			for (int j = 0; j < b.length; j++) {
				if (c[i] == b[j]) {
					count[i]++;
				}
			}

	}
		System.out.println(Arrays.toString(count));
		System.out.print("输出的交集按照出现频率从大到小排序为：");
		for (int i = 0; i < point - 1; i++) {// 比较的轮数
			for (int j = i + 1; j < point; j++) {
				if (count[i] < count[j]) {

					int temp = c[i];
					c[i] = c[j];
					c[j] = temp;
					temp = count[i];
					count[i] = count[j];
					count[j] = temp;
				}
			}
		}
		for (int i = 0; i < point; i++) {
			System.out.print(c[i] + " ");
		}

	}

}

排序方式

2、选择排序，冒泡排序

package javaproject0316;

import java.util.Arrays;

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = { 10, 98, 100, 45, 64 };
		// 选择排序

		for (int i = 0; i < a.length - 1; i++) {
			for (int j = i; j < a.length; j++) {
				if (a[i] < a[j]) {
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
		System.out.print("选择排序： " + Arrays.toString(a));
		System.out.println();

		// 冒泡排序
		for (int i = 0; i < a.length - 1; i++) {
			for (int j = 0; j < a.length - 1 - i; j++) {// 第一轮
				if (a[j + 1] < a[j]) {
					int temp = a[j + 1];
					a[j + 1] = a[j];
					a[j] = temp;
				}
			}
		}

		System.out.println("冒泡排序： "+ Arrays.toString(a));

	}

}

** 3、计算m和n的最大公约数**

package javaproject0316;

import java.util.Scanner;

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		scanner.close();
        System.out.println("最大公约数为："+ maxCommon(a, b));
	}
	public static int maxCommon(int a,int b) {
		int min = Math.min(a, b);
		//从大到小遍历，找到的第一个就是最大公约数
		for(int i = min;i > 0;i--) {
			if(a % i == 0 && b % i == 0) {
				return i;
			}
		}
		return 1;
	}
}

4、借助递归解决汉诺塔问题

package javaproject0316;

public class Test6 {

	public static void main(String[] args) {
		//汉诺塔问题
		move ('A','C','B',3);		
	}
	//移动盘子，将n个盘子，从x移动到y上借助于z
	public static void move(char x,char y,char z,int n) {
		if(n == 1) {
			System.out.println(x + " => "+y);
			return ;
		}
		//目标：将n个盘子，从x移动到y上，借助于z
		move(x,z,y,n-1);//把n-1个盘子由x移到z，借助于y
		System.out.println(x + " => " + y);//把第n个盘子由x移到y
		move(z, y, x, n-1);//把n-1个盘子由z移到y，借助于x
	}
}

创建对象对应的jvm内存结构

空指针异常

• java中规定堆内存程序员是无权利直接操作的，此时的对象等待垃圾回收器的回收，GC就会将这个垃圾对象释放掉。
  *当没有任何引用指向该对象时，该对象就会被垃圾回收器回收。再java语言中，垃圾回收器主要针对堆内存。
• 编译不出错，运行出错。
• 出现空指针异常的前提是什么："空引用"访问实例相关（对象相关）的数据时，都会出现空指针异常。

java中String类的常用方法

• String是一个对象。

• String是不属于8种基本数据类型的。
• JAVA的8种基本数据类型:基本类型分为三类:字符型(char) 、布尔型(boolean) 、数值型(byte、 short、int、long、float、 double) 。数值型又可以分为两种，整数型(int. short, long) 和浮点型(float、double)。
• String类在java.lang包中，java使用String类创建一 个字符串变量，字符串变量属于对象。String类对象创建后不能修改。
• 对象的默认值是null，所以String的默认值也时null, 但它又是一种独特的对象，有自己独特的一些性质。
• new String()和new String(" ");都是声明一个空串,这是要注意声明的是空串而不是null.
• 如果需要对字符串做很多修改，那么应该选择使用StringBuffer && StringBuilder 类。执行速度：StringBuilder > StringBuffer >String ，StringBuilder 是非线程安全的，StringBuffer 是线程安全的。

• String类的常用方法

• int length();语法: 字符串变量名.length();返回值为int类型。得到一个字符串的字符个数(中、英、空格、转义中字符皆为字符,计入长度)
• char charAt(值);语法 :字符串名.charAt(值);返回值为char类型。从字符串中取出指定位置的字符
• char toCharArray();语法:字符名.toCharArray();返回值为char数组类型。将字符串变成一个字符数组
• int indexOf(“字符”)语法 :字符串名.indexOf(“字符”);字符串名indexOf(“字符” ,值);查找一个指定的字符串是否存在,返回的是字符串的位置，如果不存在，则返回 -1
• int lastiIndexOf(“字符”)得到指定内容最后一次出现的下标
• toUpperCase(); tol owerCase();字符串大小写的转换
• String split(“字符”)根据给定的正则表达式的匹配来拆分此字符串。形成一个新的String数组。
• boolean equals(Object anObject) 语法:字符串变量名equals(字符串变量名)；返回值为布尔类型。 所以这里用if演示。比较两个字符串是否相等，返回布尔值boolean equalslgnoreCase(String)忽略大小写的比较两个字符串的值是否一模一样，返回一个布尔值

• ==和equals区别

• == 判断两个变量是否是同一个变量基本数据类型：直接比较值,引用数据类型：需要比较对应的引用的内存的首地址，即判断内存地址是否相同
• equals用来比较两个对象的内容是否相等，这个是Object类型的方法，基本数据类型不可用。equals就是通过“==”来实现的，equals判断内容相等的功能是在引用类型定义的时候通过重写String方法实现的。

• String substring(int beginIndex,int endIndex) 截取字符串包含一个参数和两个参数的方法返回字符串,一个参数时，截取从参数开始，包括该下标，到最后一个字符。两个参数时：包含第一个参数的值，不包含第二个参数的值
• boolean contains(String)判断一个字符串里面是否包含指定的内容，返回一个布尔值
• replace(char oldChar,char newChar);新字符替换旧字符,
  也可以达到去空格的效果一种。替换两个可以replace(char oldChar,char newChar).replace(char oldChar,char newChar)

package javaproject0317;

import java.util.Arrays;

public class Test1 {

	public static void main(String[] args) {

		//new开辟不同的内存空间，没有new则指向同一片内存空间
		String str = new String("你好,大家,hello,everyone");
		String str1 =new String("你好,大家,hello,everyone");
		String str2 = str1;
		String str3 = "你好,大家,hello,everyone";
		String str4 = "你好,大家,hello,everyone";		
		
		//得到一个字符串的字符个数
		System.out.println("字符的个数为：" + str.length());//20
		
		//从字符串中取出指定位置的字符
		System.out.println(" 3 位置的字符为："+str.charAt(3));//大
		//System.out.println(str.charAt(30));运行报错：StringIndexOutOfBoundsException
		
		//返回该字符的ascii码
		System.out.println(str.charAt(6) + 0);//22909
		
		//比较两个字符串是否相等,==判断地址是否相同，equals，参数是object类，判断内容是否相同		
		System.out.println(str.equals(str1));//true
		System.out.println(str == str1);//false		
		System.out.println(str2 == str1);//true
		System.out.println(str3.equals(str4));//true
		System.out.println(str3 == str4);//true
		
		/*
		 * 字符串与指定 StringBuffer 表示相同的字符序列，则返回 true；否则返回 false 
		 * 参数必须是字符串
		 */
		System.err.println(str.contentEquals(str4));//true
		
		//用于比较两个字符串的大小，如果大于，返回大于的个数，小于返回,负的小于的个数，等于返回0
		System.out.println(str.compareTo("你好,大家,hello,everyon"));//1
		System.out.println(str.compareTo("你好,大家,hello,everyone"));//0
		System.out.println(str.compareTo("你好,大家,hello,everyoneee"));//-2
		
		//得到指定内容最后一次出现的下标
		System.out.println("“ , ”最后出现的位置为：" + str.lastIndexOf(","));//11
		
		//判断一个字符串是否以指定的字符串开头、结尾
		System.out.println(str.startsWith("你好"));//true
		System.out.println(str.endsWith("d"));//false
		
		//转换大小写
		String string = "Hello World";
		System.out.println(string.toLowerCase());//hello world
		System.out.println(string.toUpperCase());//HELLO WORLD
		
		//用于返回指定的字符串在字符串中第一次出现的位置
		System.out.println(str.indexOf("h"));//6
		System.out.println(str.indexOf("e"));//7
		
		//第二个参数指定了从第几个索引位置开始查找
		System.out.println(str.indexOf("e", 10));//12
		
		//得到指定内容最后一次出现的下标
		System.out.println(str.lastIndexOf("e"));//19
		
		/*截取字符串包含一个参数和两个参数的方法返回字符串
		一个参数时，截取从参数开始，包括该下标，到最后一个字符。
		两个参数时：包含第一个参数的值，不包含第二个参数的值*/
		System.out.println(str.substring(12));//everyone
		System.out.println(str.substring(12, 13));//e
		
		//新字符替换旧字符,也可以达到去空格的效果一种
		System.out.println(str.replace("everyone", "world").replace("大家","世界"));//你好,世界,hello,world
		System.err.println(str.replace('h', 'H'));//你好,大家,Hello,everyone
		
		//只替换第一次,只能替换字符串，不能替换单个字符
		System.out.println(str.replaceFirst("e", "E"));//你好,大家,hEllo,everyone
		
		//根据给定的正则表达式的匹配来拆分此字符串。形成一个新的String数组。
		String[] string2 = str.split("");
		System.out.println(Arrays.toString(string2));//[你, 好, ,, 大, 家, ,, h, e, l, l, o, ,, e, v, e, r, y, o, n, e]

		
	}

}