国内it培训机构某马的测试题，今天做了下，都是基础的javase问题，给需要的同学

第三题
package com.itheima;


/**
 * 3、取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
 */


public class Test3 {
	public static void main(String[] args) {
		String str = "abcdekka27qoq";
		countChar(str);
	}
	
	public static void countChar(String str) {
		String s = str.toLowerCase().replaceAll("[^a-zA-Z]","");	//转换为小写字符，去除非字母字符
		
		while(s.length() > 0) {
			String ch = s.substring(0, 1);	//找到字符串第一个字符ch
			int len = s.length();			//计算当前字符串长度
			s = s.replace(ch, "");			//将字符串内的ch替换为空字符串
			int count = len - s.length();	//计算字符串前后差值，即字符ch的个数
			System.out.print(ch + "(" + count + ")");	//输出
		}
	}
	
}
第四题
package com.itheima;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


/**
 * 4、一个ArrayList对象aList中存有若干个字符串元素，
 * 现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。
 *
 */
public class Test4 {
	public static void main(String[] args) {
		//定义一个List，并添加元素
		List<String> aList = new ArrayList<>();
		aList.add("asdf");
		aList.add("asd");
		aList.add("afew");
		aList.add("abc");
		aList.add("werw");
		
		//删除List中和"abc"相同的元素
		deleteStr(aList,"abc");
		
		//输出结果
		Iterator<String> it = aList.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
	
	/*
	 * 删除list中于str相同的字符串
	 */
	public static void deleteStr(List<String> list, String str) {
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			if(str != null && str.equals(it.next())) {
				it.remove();
			}
		}
	}
}
第五题
package com.itheima;


import java.util.ArrayList;
import java.util.List;


/**
 * 5、编写程序，生成5个1至10之间的随机整数，存入一个List集合，
 * 编写方法对List集合进行排序（自定义排序算法，禁用Collections.sort方法和TreeSet），
 * 然后遍历集合输出。
 *
 */
public class Test5 {


	public static void main(String[] args) {
		
		List<Integer> list = new ArrayList<>();	//定义list
		for(int i = 0; i < 5; i++) {
			Integer num = (int)(1.0 + Math.random()*9.0);	//生成随机double数字，强制转换为int，自动打包
			list.add(num);	//将num加入list中
		}
		
		//对list进行排序
		sort(list);
		
		//输出list
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
	
	/*
	 * 选择排序法
	 */
	public static void sort(List<Integer> list) {
		int len = list.size();
		for(int i = 0; i < len-1; i++) {
			int temp = list.get(i);
			int index = i;
			for(int j = i+1; j < len; j++) {
				if(list.get(j) < temp) {
					temp = list.get(j);
					index = j;
				}
			}
			if(index != i) {
				Integer num = list.get(i);
				list.set(i, list.get(index));
				list.set(index, num);
			}
		}
	}


}
第六题
package com.itheima;


import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;


/**
 * 6、从控制台接收5个字符串存到集合中，完成以下要求：
 *  a.对集合元素按照5个字符串长度的降序进行排序，排序后将元素在控制台打印；
 *  b.对集合元素按照自然排序（字典排序，提示：字典排序为按照a~z的顺序排序），排序后将元素在控制台打印；
 *
 */
public class Test6 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<>();	//定义list
		Scanner sc = new Scanner(System.in);	//定义scanner
		int k = 0;
		//读取5个字符串并存入list
		while(k++ < 5) {
			String str = sc.nextLine();
			list.add(str);
		}
		
		
		Comparator com1 = new StringLengthComparator();	//定义字符串长度比较器
		sort(list, com1);	//按照字符串长度排序
		
		//输出排序后的list
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		Comparator com2 = new StringComparator();	//定义字符串字典顺序比较器
		sort(list, com2);	//按照字典顺序排序
		
		//输出排序后的list
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
	
	//选择排序算法
	public static void sort(List<String> list, Comparator<String> com) {
		int len = list.size();
		for(int i = 0; i < len-1; i++) {
			for(int j = i+1; j < len; j++) {
				String s1 = list.get(i);
				String s2 = list.get(j);
				if(com.compare(s1, s2) > 0) {
					list.set(i, s2);
					list.set(j, s1);
				}
			}
		}
	}
}




/*
 * 字符串长度比较器
 */
class StringLengthComparator implements Comparator<String> {


	@Override
	public int compare(String o1, String o2) {
		return o2.length()-o1.length();
	}
}


/*
 * 字符串字典顺序比较器
 */
class StringComparator implements Comparator<String> {


	@Override
	public int compare(String o1, String o2) {
		return o1.compareTo(o2);
	}
	
}
第七题
package com.itheima;


/**
 * 7、在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
 * 如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），
 * 否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法.
 */
public class Test7 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char[] chs = {'a','b','d','e','z','f'};	//定义一个char[]
		
		System.out.println(find(chs,'e'));	//测试结果：3
		System.out.println(find(chs,'k'));	//测试结果：-1
 	}
	
	public static int find(char[] chs, char ch) {
		if(chs == null)	//判断非空
			return -1;
		for(int i = 0; i < chs.length; i++) {
			if(chs[i] == ch) {
				return i;	//如果找到，返回第一次出现的位置
			}
		}
		return -1;	//否则返回-1
	}


}
第八题
package com.itheima;
/**
 * 
 *	8、写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
 *	1	2	3	4
 *	12	13	14	5
 *	11	16	15	6
 *	10	9	8	7
 *
 */
public class Test8 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		fun(4);
	}


	public static void fun(int n) {
		int[][] a = new int[n][n];	//定义n阶方阵
		for (int i= 1; i <= n; i++){
			for (int j= 1; j <= n; j++) {
				a[i-1][j-1] = num(i,j,n);	//求解各个元素的值
			}
		}
		
		//输出矩阵
		for (int i= 0; i < n; i++){
			for (int j= 0; j < n; j++) {
				System.out.print(a[i][j] + "\t");
			}
			System.out.println();
		}
		
	}


	/*
	 * 递归求解个元素的
	 */
	public static int num(int x, int y, int n) {
		if ((x==1) && (y==1)) 
			return 1;
		if ((x-y>=1)&&(x+y<=n)) 
			return (1 + num(x+1,y, n));
		if ((x-y>=1)&&(x+y>n)) 
			return (1 + num(x, y+1, n)); 
		if ((x-y<1)&&(x+y<=n+1)) 
			return (1 + num(x, y-1, n));
		if ((x-y<1)&&(x+y)>n+1) 
			return (1 + num(x-1,y, n));
		else 
			return 0;
	} 


}
第九题
package com.itheima;


import java.util.ArrayList;
import java.util.List;


/**
 * 9、编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
 *
 */
public class Test9 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list = new ArrayList<>(10);	//定义list
		int k = 0;
		while(k++ < 10) {
			int num = (int)(Math.random()*19.0 + 1.0);
			//如果list中已经存在num，则不断生成新的随机数，直到list中不存在为止
			while(isContain(list, num)) {
				num = (int)(Math.random()*19.0 + 1.0);
			}
			list.add(num);
		}
		
		//输出list
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
	
	/*
	 * 判断list中是否存在等于num的元素
	 */
	public static boolean isContain(List<Integer> list, int num) {
		for(int i = 0; i < list.size(); i++) {
			if(list.get(i) == num)
				return true;
		}
		return false;
	}

}
第十题
package com.itheima;


import java.util.ArrayList;
import java.util.List;


/**
 * 10、有100个人围成一个圈，从1开始报数，
 * 报到14的这个人就要退出。然后其他人重新开始，
 * 从1报数，到14退出。问：最后剩下的是100人中的第几个人？
 *
 */
public class Test10 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list = new ArrayList<>();
		for(int i = 1; i <= 100; i++)
			list.add(i);
		
		int n = fun(list);
		
		System.out.println("剩下的是第" + n + "个人。");
	}


	private static int fun(List<Integer> list) {
		
		int count = 0;
		int i = 0;
		while(list.size() > 1) {
			count++;	//报数
			if(count == 14) {
				list.remove(i);	//报14的人去掉
				count = 0;	//重新计数
				i = decrease(i,list);	//注意，这里由于删除了一个人，所以i要回到上一个人那里
			}
			i = increase(i,list);	//i指向下一个人
			
		}
		
		return list.get(0);
	}


	private static int increase(int i, List<Integer> list) {
		if(i == list.size()-1) 
			return 0;
		else
			return i+1;
	}


	private static int decrease(int i, List<Integer> list) {
		if(i == 0)
			return list.size()-1;
		else
			return i-1;
	}




}