一.关于求解一个数组中的重复次数最多的数和重复次数最少的数
方法1:
对于给定的数组,重新声明一个数组,新的数组中存放每个旧数组中每个元素对应的个数,最后求解出新数组中最大的数和最小的数的下标。
例如:oldArr[5] = {3,2,6,3,5}; 那么newArr[5] = {2,1,1,2,1}。因为重复最多的数或者重复最少的数在大多数情况下不只有一个,可能是多个,所以一般情况下用数组存放,那么得到的结果也就比较准确。
方法2:
类中有两个函数,repeatMostNum(),repeatLeastNum(),参数是一个数组,返回的结果用集合存放,得到的结果比较准确。
源码附上:(自己写测试类可以测试一下,参数为int类型的数组,返回值为ArrayList集合)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Map.Entry;
public class FindRepeatNumInArray {
private static List<Integer> repeatMostNum(int [] args) {
/**
* 功能分析:整型数组
* 1.全部一样,为同一个数,重复最多的数的数的次数为:数组的长度
* 2.全部不一样,都为不同的数,重复最多的数的次数为:1
* 3.多个不同的数,多个相同的数,重复最对的数为:好几个不同的数:
*/
HashMap<Integer, Integer> number = new HashMap<Integer, Integer>();
Arrays.sort(args);
// 对数组首先进行排序 使得所有相同的数聚集在一起
int start = args[0];
// 定义初始比较值
int count = 0;
// 计数器
for (int i = 0; i < args.length; i++) {
if (args[i] == start) {
// 当前值与起始值 是一个值 比较的结果为真,所以至少为count的最小值为1 如果接下来的数 和起始值是一样的额 那么计数器累加
count++;
if (i == args.length - 1) {
number.put(args[i], count);
}
} else {
/* 如果接下来的值 不和起始值一样 ,且累加器的值比最大值还有大 ,
* 那么就把当前值赋值给最大值 并且记录元素的位置
*/
number.put(args[i - 1], count);
start = args[i];
// 起始值变为新值得开始
i -= 1;
count = 0;
// 计数器清 0 开始重新计数
}
}
// 对哈希Map进行遍历
int[] key = new int[args.length];
int max = key[0];
int j = 0;
Iterator<Entry<Integer, Integer>> iter = number.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) iter.next();
int mValue = entry.getValue();
int mKey = entry.getKey();
if (mValue>max) {
//清空key数组中的值
j = 0;
for(int i = 0;i<key.length;i++) {
key[i] = 0;
}
max = mValue;
key[j] = mKey;
} else if(mValue == max) {
j=j+1;
key[j] = mKey;
}
}
List<Integer> list = new ArrayList<>();
j = key.length-1;
int flag = 0;
while(j>=0) {
if (key[j]!=0 && flag == 0) {
list.add(key[j]);
flag = 1;
}else if(flag == 1) {
list.add(key[j]);
}
j--;
}
return list;
}
/**
* 功能分析:整型数组
* 1.全部一样,为同一个数,重复最多的数的数的次数为:数组的长度
* 2.全部不一样,都为不同的数,重复最多的数的次数为:1
* 3.多个不同的数,多个相同的数,重复最对的数为:好几个不同的数:
*/
private static List<Integer> repeatLeastNum(int [] args) {
HashMap<Integer, Integer> number = new HashMap<Integer, Integer>();
Arrays.sort(args);
// 对数组首先进行排序 使得所有相同的数聚集在一起
int start = args[0];
// 定义初始比较值
int count = 0;
// 计数器
for (int i = 0; i < args.length; i++) {
if (args[i] == start) {
// 当前值与起始值 是一个值 比较的结果为真,所以至少为count的最小值为1 如果接下来的数 和起始值是一样的额 那么计数器累加
count++;
if (i == args.length - 1) {
number.put(args[i], count);
}
} else {
// 如果接下来的值 不和起始值一样 ,且累加器的值比最大值还有大 ,那么就把当前值赋值给最大值 并且记录元素的位置
number.put(args[i - 1], count);
start = args[i];
// 起始值变为新值得开始
i -= 1;
count = 0;
// 技术器清 0 开始重新计数
}
}
// 对哈希Map进行遍历
int[] key = new int[args.length];
int min = args.length;
int j = 0;
Iterator<Entry<Integer, Integer>> iter = number.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) iter.next();
int mValue = entry.getValue();
int mKey = entry.getKey();
if (mValue<min) {
//清空key数组中的值
j = 0;
for(int i = 0;i<key.length;i++) {
key[i] = 0;
}
min = mValue;
key[j] = mKey;
} else if(mValue == min) {
j=j+1;
key[j] = mKey;
}
}
List<Integer> list = new ArrayList<>();
j = key.length-1;
int flag = 0;
while(j>=0) {
if (key[j]!=0 && flag == 0) {
list.add(key[j]);
flag = 1;
}else if(flag == 1) {
list.add(key[j]);
}
j--;
}
return list;
}
}
二,字符串编码(该有的注释为都写了,参数为:字符串,编码位数,重载值(数字表示返回数组,true表示返回字符串))
package NullChenUtil;
/**
* (字符串中的内容一律按照ASCII处理 1值为表示 49)
* 编码规则:
* 对参数字符串进行横向编码。
* 给定字符串,指定编码位数,也就是几个字符串一起相加得到某个值对这个值进行分解继续相加,知道为个位数
* 分析:
* 1.首先 字符串的字面常量最大长度为65535,也就是说可以存储65534个字符,
* 假定编码为为65534,也就是0+1+2+...+65534,得到第一次的编码值,最终值为个位数,
* 大概是65535的平方除以2等于2147385355,然后对各个位数求和也不会超过99,
* 那么这样 的迭代次数最多3次。
* 1.对一段字符串进行编码)
* @author NullChen
*
*/
public class StringCode {
//对字符串进行横该字符串已经能被6整除
public int[] levelAdd(String str,int bit,int b) {
/*
*如果能被整除
*那么就不做处理
*如果能被整除
*那么就做处理
*处理方法 : 使用$补齐 是得能被整除
*/
StringBuilder sd = new StringBuilder(str);
if(str.length()%bit!=0) {
for (int i = 0; i <bit-str.length()%bit; i++) {
sd.append('$');
}
}
str = sd.toString();
int k = 0;
//k为结果存储计数器
int sum = 0;
//求和
int len = str.length()/bit;
//有多少这样的组
char[] newStr = str.toCharArray();
//将字符串转换成字符数组
int[] result = new int[len];
//存储每组的结果
//计算每组的结果,然后存储到result 中
for (int i = 0; i < newStr.length; i+=bit) {
for(int j = 0;j<bit;j++) {
if(newStr[i+j] == '$') {
//每组的结果
sum += 0;
}else {
sum += newStr[i+j];
}
}
result[k++] = sum;
sum = 0;
}
//System.out.println(Arrays.toString(result));
return this.dealResult(result);
}
//默认b为true
public String levelAdd(String str,int bit,boolean b) {
if(b) {
int[] it = this.levelAdd(str, bit, 0);
StringBuilder sd = new StringBuilder();
for (int i = 0; i < it.length; i++) {
sd.append(it[i]+"");
}
return sd.toString();
}
return null;
}
//对结果集进行处理
private int[] dealResult(int[] result) {
// TODO Auto-generated method stub
int b = 3;
int len = result.length;
//首先获取结果集的长度
while(b-->0) {
for(int i = 0;i<len;i++) {
String str = result[i]+"";
result[i] = 0;
//System.out.println("result[i]:"+str.length());
if(charNumToNukm(result[i])/10!=0) {
for(int j = 0;j<str.length();j++) {
//System.out.println(str.charAt(j));
result[i]+=charNumToNukm(str.charAt(j));
}
}
}
//每部处理后的结果集
//System.out.println(Arrays.toString(result));
}
return result;
}
//字符数字向数字转换
private int charNumToNukm(int charNum) {
// TODO Auto-generated method stub
return charNum-48;
}
}
三,指定路径下的目录的树形结构(参数:指定目录,缩进几个制表位)
package NullChenUtil;
import java.io.File;
public class TreeDirectory {
/**
* 实现某个路径下的树形结构
* @param file
* @param k
*/
public void tDirectory(File file,int k) {
File[] childList = file.listFiles();
if(childList!=null) {
for (int i = 0; i < childList.length; i++) {
File f = childList[i];
for (int j = 0; j < k; j++) {
System.out.print("\t");
}
System.out.println(f.getName());
if(f.isDirectory()) { // 检测这些是不是目录 如果是目录的话就向下递归知道不是目录为之!
tDirectory(f,k+1);
}
}
}else {
System.out.println("文件为null");
}
}
}