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;
}
}