java—笔试题记录

1：输入一个字符串，返回字符串中第一个只出现一次的字符。

简单方法：

 

public class FirstLetter {
  public static void main(String [] args){
	  Scanner in = new Scanner(System.in);
	  String st = in.next();
	  System.out.println(getFiratLitter(st));
  }
  
  public static String getFiratLitter(String str){
	  for (int i=0;i<str.length();i++){
		  String a = str.substring(0,i)+str.substring(i+1);//去掉这个字符的字符串
		  if(a.indexOf(str.charAt(i))==-1){
			 str=String.valueOf(str.charAt(i));
			  break;
		  }
	  }
	return str;
  }
}

第二种方法：（较复杂）
 

 

 

public class FirstLetter {
	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);
		String mstr = input.next();
		int n = FirstNotRepeatingChar(mstr);
		System.out.print(mstr.charAt(n));
	}

	public static int FirstNotRepeatingChar(String str) {
		HashMap<Character, Integer> map1 = new HashMap<Character, Integer>();// 字母+個數,前面为key，后面为value
		HashMap<Character, Integer> map2 = new HashMap<Character, Integer>();// 字母+索引,前面为key，后面为value

		for (int i = 0; i < str.length(); i++) {
			char n = str.charAt(i);
			if (!map1.containsKey(n)) {// 如果map1中沒有这个字母，则向里面添加
				map1.put(n, 1);
				map2.put(n, i);
			} else {// 如果map1中有这个字母，则map1对应地方的个数+1，map2去掉这个字母
				map1.put(n, map1.get(n) + 1);
				// 去掉之前添加的这个字母，这次也不添加。这一步之后，map2中就只有只出现过一次的字母。
				map2.remove(n);
			}
		}//map2.values()返回map中的values数组，索引数组迭代
		//尖括号表示只接受这个类型的参数
		Iterator<Integer> iter = map2.values().iterator();
		int min = -1;
		while (iter.hasNext()) {
			int i = iter.next();
			// 第一次满足条件，min等于第一个i，然后iter中按位次向后挪。
			// 因为上一步的存在，索引是不连续的
			if (min == -1 || i < min) {
				min = i;
			}
		}
		return min;// 返回这个序号
	}
}

/*
 * 迭代器（Iterator）
 * 
 * 迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
 * 
 * Java中的Iterator功能比较简单，并且只能单向移动：
 * 
 * (1)
 * 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator
 * ()方法是java.lang.Iterable接口,被Collection继承。
 * 
 * (2) 使用next()获得序列中的下一个元素。
 * 
 * (3) 使用hasNext()检查序列中是否还有元素。
 * 
 * (4) 使用remove()将迭代器新返回的元素删除。
 * 
 * Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，
 * 也可以从List中插入和删除元素。
 */
   		//尖括号表示只接受这个类型的参数
		Iterator<Integer> iter = map2.values().iterator();
		int min = -1;
		while (iter.hasNext()) {
			int i = iter.next();
			// 第一次满足条件，min等于第一个i，然后iter中按位次向后挪。
			// 因为上一步的存在，索引是不连续的
			if (min == -1 || i < min) {
				min = i;
			}
		}
		return min;// 返回这个序号
	}
}

/*
 * 迭代器（Iterator）
 * 
 * 迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
 * 
 * Java中的Iterator功能比较简单，并且只能单向移动：
 * 
 * (1)
 * 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator
 * ()方法是java.lang.Iterable接口,被Collection继承。
 * 
 * (2) 使用next()获得序列中的下一个元素。
 * 
 * (3) 使用hasNext()检查序列中是否还有元素。
 * 
 * (4) 使用remove()将迭代器新返回的元素删除。
 * 
 * Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，
 * 也可以从List中插入和删除元素。
 */
   

 

 

2.编写函数求得输入一段英文句子，获得这个句子中每个单词的个数

 

public class WordCount {

		public static void main(String arg[]){
			ArrayList<String> al=new ArrayList<String>();
			Scanner s=new Scanner(System.in);
			StringTokenizer st=new StringTokenizer(s.nextLine());
			while(st.hasMoreTokens()){
				String ss=st.nextToken();
				//判断末尾是否有非字母的字符，有则去掉
				if(ss.charAt(ss.length()-1)>'z'||ss.charAt(ss.length()-1)<'A')
					ss=ss.substring(0,ss.length()-1);
				al.add(ss);
			}
			while(al.size()!=0){
			String sl;
			int count;
			sl=al.remove(0);//每次循环都是第一个
			count=1;
			while(al.indexOf(sl)!=-1){//indexOf返回第list中第一个匹配项的索引，如果没有就返回-1
				count++;
				al.remove(sl);
			}
			System.out.println(sl+" "+count);
			}
		}
	
}

3.java用递归方法遍历文件下所有文件

/**
 * Java遍历文件夹下的所有文件（递归调用和非递归调用）
 * 
 * 
 * @author Anshay
 * @since Dec 5, 2017
 */
public class Files {

	public static void main(String[] args) {
		traverseFolder2("D://vfs");
	}

	/**
	 * 非递归遍节点下子节点（深度只有一层）
	 * 
	 * @param path
	 */
	public static void traverseFolder1(String path) {
		int fileNume = 0;
		int folderNum = 0;
		File file = new File(path);
		if (file.exists()) {
			LinkedList<File> list = new LinkedList<File>();
			File[] files = file.listFiles();
			for (File f : files) {
				if (f.isDirectory()) {
					System.out.println("文件夹:" + f.getAbsolutePath());
					list.add(f);
					folderNum++;
				} else {
					System.out.println("文件:" + f.getAbsolutePath());
					list.add(f);
					fileNume++;
				}
			}
			System.out.println("文件夹共有:" + folderNum + ", 文件共有:" + fileNume);
		} else {
			System.out.println("文件夹不存在");
		}
	}

	/**
	 * 递归遍历文件下所有文件
	 * 
	 * @param path
	 */
	public static void traverseFolder2(String path) {
		File file = new File(path);
		File[] files = file.listFiles();
		for (File f : files) {
			if (f.isDirectory()) {
				System.out.println("文件夹:" + f.getAbsolutePath());
				traverseFolder2(f.getAbsolutePath());// 递归去查该节点下的子节点
			} else {
				System.out.println("文件:" + f.getAbsolutePath());
			}
		}
	}
}

 

 

 

 

4.遍历一棵二叉树

package practice;

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

import org.w3c.dom.Node;

/**
 * 遍历一个二叉树
 * 前：根左右
  *   中：左根右
  *   后：左右根
  *   即以读到根结点的顺序命名。
 * @author Anshay
 * @since Dec 11, 2017
 */
public class Tree {

	private Node root;
	private static List<Node> list = new ArrayList();

	public Tree() {
		init();// 初始化树
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Tree tree = new Tree();
		System.out.println("根节点是：" + tree.root.data);
		System.out.println("以下示例前序遍历");
		preOrder(tree.root);
		for (Node node : tree.getResult()) {
			System.out.println(node.data);
		}
	}

	/**
	 * 初始化一棵二叉树-由页到根
	 * 
	 * @param ----d
	 * @param --c---e
	 * @param -a-b---f
	 */
	private void init() {
		Node a = new Node("A", null, null);
		Node b = new Node("B", null, null);
		Node f = new Node("F", null, null);
		Node c = new Node("C", a, b);
		Node e = new Node("E", null, f);
		Node d = new Node("D", c, e);
		root = d;
	}

	/**
	 * 定义节点类
	 * 
	 * @author Anshay
	 * @since Dec 11, 2017
	 */
	private class Node {
		private String data;// 节点
		private Node leftChild;// 左儿子
		private Node rightChild;// 右儿子

		public Node(String data, Node leftChild, Node rightChild) {
			this.data = data;
			this.leftChild = leftChild;
			this.rightChild = rightChild;
		}

		public String getData() {
			return this.data;
		}
	}

	/**
	 * 前序遍历
	 * 
	 * @param node
	 */
	public static void preOrder(Node node) {
		// 先将根节点加到集合中，做到先根节点
		list.add(node);
		if (node.leftChild != null) {
			// 如果左儿子不为空，就去找左二子下的子树的前序遍历
			preOrder(node.leftChild);
		}

		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的前序遍历
			preOrder(node.rightChild);
		}
	}

	/**
	 * 中序遍历
	 * 
	 * @param node
	 */
	public static void inOrder(Node node) {
		// 如果左儿子不为空，就去找左二子下的子树的中序遍历
		if (node.leftChild != null) {

			inOrder(node.leftChild);
		}
		// 遍历到第一个没有左儿子的地方的根节点加到集合，保证左儿子-父节点-右儿子的顺序
		list.add(node);

		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的中序遍历
			inOrder(node.rightChild);
		}
	}

	/**
	 * 后序遍历
	 * 
	 * @param node
	 */
	public static void postOrder(Node node) {
		// 如果左儿子不为空，就去找左二子下的子树的后序遍历
		if (node.leftChild != null) {
			postOrder(node.leftChild);
		}
		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的后序遍历
			postOrder(node.rightChild);
		}
		// 遍历到第一个没有子节点的的地方的根节点加到集合，然后才层层退出去加右节点和父节点保证左儿子-右儿子-父节点的顺序
		list.add(node);
	}

	public List<Node> getResult() {
		return list;
	}

}
前：根左右
  *   中：左根右
  *   后：左右根
  *   即以读到根结点的顺序命名。
 * @author Anshay
 * @since Dec 11, 2017
 */
public class Tree {

	private Node root;
	private static List<Node> list = new ArrayList();

	public Tree() {
		init();// 初始化树
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Tree tree = new Tree();
		System.out.println("根节点是：" + tree.root.data);
		System.out.println("以下示例前序遍历");
		preOrder(tree.root);
		for (Node node : tree.getResult()) {
			System.out.println(node.data);
		}
	}

	/**
	 * 初始化一棵二叉树-由页到根
	 * 
	 * @param ----d
	 * @param --c---e
	 * @param -a-b---f
	 */
	private void init() {
		Node a = new Node("A", null, null);
		Node b = new Node("B", null, null);
		Node f = new Node("F", null, null);
		Node c = new Node("C", a, b);
		Node e = new Node("E", null, f);
		Node d = new Node("D", c, e);
		root = d;
	}

	/**
	 * 定义节点类
	 * 
	 * @author Anshay
	 * @since Dec 11, 2017
	 */
	private class Node {
		private String data;// 节点
		private Node leftChild;// 左儿子
		private Node rightChild;// 右儿子

		public Node(String data, Node leftChild, Node rightChild) {
			this.data = data;
			this.leftChild = leftChild;
			this.rightChild = rightChild;
		}

		public String getData() {
			return this.data;
		}
	}

	/**
	 * 前序遍历
	 * 
	 * @param node
	 */
	public static void preOrder(Node node) {
		// 先将根节点加到集合中，做到先根节点
		list.add(node);
		if (node.leftChild != null) {
			// 如果左儿子不为空，就去找左二子下的子树的前序遍历
			preOrder(node.leftChild);
		}

		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的前序遍历
			preOrder(node.rightChild);
		}
	}

	/**
	 * 中序遍历
	 * 
	 * @param node
	 */
	public static void inOrder(Node node) {
		// 如果左儿子不为空，就去找左二子下的子树的中序遍历
		if (node.leftChild != null) {

			inOrder(node.leftChild);
		}
		// 遍历到第一个没有左儿子的地方的根节点加到集合，保证左儿子-父节点-右儿子的顺序
		list.add(node);

		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的中序遍历
			inOrder(node.rightChild);
		}
	}

	/**
	 * 后序遍历
	 * 
	 * @param node
	 */
	public static void postOrder(Node node) {
		// 如果左儿子不为空，就去找左二子下的子树的后序遍历
		if (node.leftChild != null) {
			postOrder(node.leftChild);
		}
		if (node.rightChild != null) {
			// 如果右儿子不为空，就去找右儿子下的子树的后序遍历
			postOrder(node.rightChild);
		}
		// 遍历到第一个没有子节点的的地方的根节点加到集合，然后才层层退出去加右节点和父节点保证左儿子-右儿子-父节点的顺序
		list.add(node);
	}

	public List<Node> getResult() {
		return list;
	}

}