set：无重复，无序
list:有序，有重复
直接输出一个数组：Arrays.toString(数组）
快速查找类：ctrol+shitf+t
java.lang.ClassCastException:java.lang.Long cannot be cast to java.lang.Integer:表示类型转换异常
mysql
1 内连接：
select * from t_customer c,t_linkman l where c.cid=l.clid
select * from t_customer c INNER JION t_linkman l ON c.cid=l.clid
2 左外连接：
select * FROM t_customer c LEFT OUTER JION t_linkman l ON c.cid=l.clid
3 右外连接
select * FROM t_customer c RIGHT OUTER JION t_linkman l ON c.cid=l.clid
动态磁盘不能装多系统
vector:动态容量
把String转换成Char数组 str.toCharArray()
new 一个set
Set<Character> set = new LinkedHashSet<Character>()
new 一个list
List list=new ArrayList();
List<Integer> list1=new ArrayList<Integer>();
把StringBuffer 清空 ： sb.setLength(0); // 清空
while(iter.hasNext()){
lis.add(iter.next());
}
SCSII表：A:65 Z:90
a:97 z:122
1:49
9:97
result.elementAt(4)-'0'
s.substring(0,2); substring方法是有头无尾的
Stack<Character> a = new Stack<Character>();
vector:add方法和remove()方法
//泛形要求能包容的是对象类型，而基本类型在java里不属于对象。但是基本类型都有其包装类型，也就是对象类型：
Stack<Integer> a = new Stack<Integer>();
a.push('}');
Stack.pop();
public E pop()
在这个堆栈的顶部删除对象，并返回该对象的值作为该函数的值。
stack.peek()
查看此堆栈顶部的对象，而不将它从堆栈中删除。
char[] x = n.toCharArray();
int a = x[0]-'0';
Stack<Character> a = new Stack<Character>();
List src = new Vctor();//这里实现了一边删除一边添加，因为是list，所以删除是删除前面的元素，但是添加是在最后添加的
src.add(src.remove(0));
//list
ArrayList<String> list=new ArrayList();
List dst = new Vector();
//s.substrin(1) substring是有头无尾，截取从第一元素开始到最后一个元素
return getFirstNum(s.substring(1)); // 填空
for(int j=i*3;j<i*3+3;j++){
//***************这里只要不满足三个一组，就会被逐个添加到list中，并且满足了3个一组的时候就会删除上一组
lis.get(i)[j%3] = s[j].toCharArray();
}
浮点数运算： System.out.printf("%.3f",sum/500000f);
关于IO：
File inFile = new File("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/test.java");
FileInputStream fileInputStream;
fileInputStream = new FileInputStream(inFile);
InputStreamReader inputStreamReader = new InputStreamReader(
fileInputStream);
BufferedReader bufferedReader = new BufferedReader(
inputStreamReader);
File outFile = new File("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/test.html");
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
OutputStreamWriter outStreamWriter = new OutputStreamWriter(
fileOutputStream);
BufferedWriter bufferedWriter = new BufferedWriter(outStreamWriter);
outStreamWriter.write("<html>\n");
关于IO2： // 定义读取内容
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 定义输出内容
PrintWriter pw = new PrintWriter("b.html");
String s;
pw.write("<html><body>\n");
while((s=br.readLine())!=null){
pw.write(process(s)); // 输出内容
}
pw.write("</body></html>");
br.close();
pw.close();
System.out.println("转换成功");
关于IO3：
public static void main(String[] args) throws Exception{
String value = "中国风\n";
String value2 = "a 中国风\n";
// 向文件中写入内容
PrintWriter pw = new PrintWriter("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/temp.txt","UTF-8");
pw.write(value);
pw.write(value2);
pw.close();
// 从文件中读取内容
BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream("temp.txt"),"utf-8"));
String b;
while((b = br.readLine())!=null){ // 按行读取
System.out.println(b);
}
br.close();
}
array[0]=true;
for (int i = 1; i <array.length; i++) {
array[i]=(i>=8&&!array[i-8])||(i>=7&&!array[i-7])||(i>=3&&!array[i-3])||(i>=1&&!array[i-1]);
}
//这里一般会添加一句这个，不然会出错
scanner.nextLine();
while((n--)>0){
for (int i = 0; i < s.length(); i++) {
array[i%6]+=(int)(s.charAt(i));
}
for(int[] x: t){
for(int y:x){
System.out.print(y+"\t");
}
System.out.println();
}
System.out.printf("%4d",array[i][j]);
for (int i = 0; i < pair.length(); i++) {
vector.remove((Character)pair.charAt(i));
array[i/5][i%5]=pair.charAt(i);
}
for (int i = 0,j=pair.length() ; i < vector.size()-1; i++,j++) {
array[j/5][j%5]=vector.elementAt(i);
}
ss[i++] = sb.substring(0,2);
sb.delete(0, 2);
String string=priorityBlockingQueue.poll();//poll() 检索并移除此队列的头，或返回 null如果队列为空。
Set<Set<Integer>>set=new LinkedHashSet<>();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
iterator 无序，set也是无序的，arraylist是有序的
List<MyPoint> list = new ArrayList<MyPoint>();
List<Integer> lst = new Vector<Integer>();
lst.addAll(Arrays.asList(12, 127, 85, 66, 27, 34, 15, 344, 156, 344,
29, 47));
lst.set(i, a);
Rectangle()
构建了一种新的 Rectangle其左上角为（0， 0）在坐标空间，其宽度和高度均为零。
for (int i = len - 1; i > 0; i--) { // 当值等于3时，实现逢3进位
if (sign[i] == 3) {
sign[i] = 0; // sign[i] 归零
sign[i - 1]++; // sign[i-1]进位
}
}
这个比值四舍五入后已经达到了与0.618034一致的精度。
表示方法：if(Math.abs((double)a/b-0.618034)<0.000001){
System.out.println(a+"/"+b+" = "+(double)a/b);
break;
}
解决精度缺失问题：可以用BigDecimal对象
一般来说，可以使用BigDecimal的构造方法或者静态方法的valueOf()方法把基本类型的变量构建成BigDecimal对象。
1 BigDecimal b1 = new BigDecimal(Double.toString(0.48));
2 BigDecimal b2 = BigDecimal.valueOf(0.48);
对于常用的加，减，乘，除，BigDecimal类提供了相应的成员方法。
1 public BigDecimal add(BigDecimal value); //加法
2 public BigDecimal subtract(BigDecimal value); //减法
3 public BigDecimal multiply(BigDecimal value); //乘法
4 public BigDecimal divide(BigDecimal value); //除法
ROUND_HALF_UP: 遇到.5的情况时往上近似,例: 1.5 ->;2
ROUND_HALF_DOWN : 遇到.5的情况时往下近似,例: 1.5 ->;1
BigDecimal a = new BigDecimal(1.5);
System.out.println("down="+a.setScale(0,BigDecimal.ROUND_HALF_DOWN)+"/tup="+a.setScale(0,BigDecimal.ROUND_HALF_UP));
结果:down=1 up=2
看这个例子就明白了!
public static Date addDate(Date date,long day) throws ParseException {
long time = date.getTime(); // 得到指定日期的毫秒数
day = day*24*60*60*1000; // 要加上的天数转换成毫秒数
time+=day; // 相加得到新的毫秒数
return new Date(time); // 将毫秒数转换成日期
}
Set<Set<Integer>> sets = new LinkedHashSet<Set<Integer>>();
判断闰年：if ((year%4==0&&year%100!=0)||year%400==0) {
return 366;
}
//除掉序号能被2整除的
for(int i=vector.size()-1;i>=1;i--){
//巧妙的从后往前删
if(i%2==0){
vector.remove(i);
}
}
int i = (int) (Math.random() * 60);//填空
int[] temp = new int[]{i,j,k,m};
Arrays.sort(temp); // 排序
Set<Integer> sets = new HashSet<Integer>();
LinkedList<String> s
s.getFirst(); //返回第一个元素
s.removeLast();//删除最后一个元素
private Map map = new HashMap();
List<Character> t = (List<Character>) map.get(parent);
public BigInteger mod(BigInteger m)
返回一个BigInteger的价值 (this mod m）。
这种方法不同于 remainder，它总是返回一个非负BigInteger。
-100 mod 3 is 2
得到最大公约数： // 得到最大公约数(辗转相除)
public static BigInteger gdc(BigInteger m,BigInteger n) {
BigInteger r = m.mod(n);
while(r.compareTo(BigInteger.ZERO)!=0){
m = n;
n = r;
r = m.mod(n);
}
return n;
}
得到最小公倍数：
m = m.multiply(n).divide(gdc(m, n)); // 得到最小公倍数
int g = (n+7)/8; // 分组数 g 17人时，还是的跟3组，24人还是得分三组
但如果是16人可以分成两组，16+7/8=2.**，==int(2.**)==2
System.out.println("输入整数n");
int n = scan.nextInt();
scan.nextLine();
String[] s = new String[n];
for(int i=0;i<n;i++){
s[i] = scan.nextLine(); // 初始数据
}
ArrayList<String> lis = new ArrayList<String>(); // 记录全部交换结果(检查重复用)
Queue<String> queue = new LinkedList<String>(); // 队列(用来测试所有可能)
queue.offer(t); // 入队
lis.add(t); // 添加记录
手机百度页面搜索霍金动画
sb.insert(0, s).toString();
insert(index,s):在【index】元素后面添加s
System.out.println(new DecimalFormat(".00").format(s));
StringBuffer ss = new StringBuffer();
ss.setLength(0)//清空临时串
利用数组求BigInteger的加减乘除
LUCAS:C（n,m）%p=C(n/p,m/p)%p*(n%p,m%p)%p
熟练度：
arrays
public static int getNum(char c){
switch(c){
case 'I': return 1;
case 'V': return 5;
case 'X': return 10;
case 'L': return 50;
case 'C': return 100;
case 'D': return 500;
case 'M': return 1000;
}
return 0;
}
static HashMap<Character,Integer> Map =
new HashMap<Character,Integer>(){
{
put('I',1);
put('V',5);
put('X',10);
put('L',50);
put('C',100);
put('D',500);
put('M',1000);
}
};
汉字转化为数字的关键步骤：return (b[0]<<8&0xff00) + (b[1]&0xff); b
b = (""+c).getBytes("GB2312");
for (;;) {
if (a.size() == 1)
break;
for (int k = 0; k < 2; k++)
a.add(a.remove(0));// 填空
a.remove(0);
}
return reverseString(x.substring(1)) + x.charAt(0); // 填空
十进制与任意进制的互换：The112
负数在计算机中用补码表示，补码：原码取反+1
十进制负数-->二进制：绝对值十进制-->二进制，取反，+1
二进制负数-->十进制： 二进制-1，取反，计算得到十进制
(int) Math.sqrt(n):开根号
Math.abs(n):返回绝对值
Math.mod:求余
Pattern p=Pattern.compile("([0-9]+)");
Matcher m=p.matcher(s);
String fin="";
int st=0;
while(m.find()){//find方法扫描输入序列寻找匹配模式下的子序列
int start=m.start();
int end=m.end();
fin+=s.substring(st,start);
System.out.println("fin:"+fin);
if(s.charAt(start-1)!=' ')fin+="_";
System.out.println("fin:"+fin);
System.out.println(m.group(1));
fin+=m.group(1);
if(s.charAt(end)!=' ')fin+="_";
st=end;
}
m.group
String[] ss = s.split("[\\s]+"); //匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
ss[i] = sb.replace(0, 1, up).toString();
String num,num2;//直接替换字符串
ss[i] = ss[i].replace(num, num2);
if(ss[i].startsWith("_")){ // 去头"_"
ss[i] = ss[i].substring(1);
}
if(ss[i].endsWith("_")){ // 去尾"_"
ss[i] = ss[i].substring(0,ss[i].length()-1);
}
(char)('A'-1+n%26);
lis.add(Arrays.copyOf(n, n.length));
lis.add(n);
Arrays.sort(d); //排序
//该实现类需要自己实现一个继承了 Comparator 接口的类， 在插入资源时会按照自定义的排序规则来对资源数组进行排序。 其中值大的排在数组后面 ，取值时从数组投开始取
public static String elementOfPriorityBlockingQueue
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Integer integer2 = (Integer) iterator.next();
System.out.print(integer2);
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Integer integer2 = (Integer) iterator.next();
System.out.print(integer2);
2018年3月21日18:20:06
正则表达式：
1.元字符
. \d \D \s \S \w \W
2.限定符：
？ * + {n}正好n次 {n,m} {n,}至少出现n次
public String toString(int p) 返回当前大整数对象p进制的字符串表示
public BigInteger remainder(BigInteger val)返回当前大整数对象与参数指定的大整数对象的余。
。
例如：String s = String.format(“%.2f”,3.141592);那么s就是“3.14”.
String s=format("%d元%0.3f公斤%d台",888,999.777666,123); 那么,s就是"888元999.778公斤123台"。
String s=String.format(“不是从左向右：%2$.3f,%3$d,%1$d”,x,y,100);
字符串s就是 不是从左向右：3.142,100,888
注2：如果准备在“格式化模式”中包含普通的%，在编写代码时需要连续键入两个%，如：
String s=String.format("%d%%",89); 输字符串s是："89%"
1）%d，%o，%x和%格式符可格式化byte、Byte、short、Short、int、Integer、long和Long型数据
，详细说明见Page204. 例如，对于：
String s
= String.format("%d,%o,%x,%X",703576,703576,703576,703576);
字符串s就是：703576,2536130,abc58,ABC58
import java.util.regex.*;
public class Example8_22 {
public static void main(String args[ ]) {
String s = "市话76.8元,长途:167.38元,短信12.68";
String regex = "[0123456789.]+"; //匹配数字序列
Pattern p =Pattern.compile(regex); //模式对象
Matcher m =p.matcher(s); //匹配对象
double sum =0;
while(m.find()) {
String item = m.group();
System.out.println(item);
sum = sum+Double.parseDouble(item);
}
System.out.println("账单总价格:"+sum);
}
}
List<T> myList = new ArrayList<T>()
Iterator iterator = myList.iterator(); // 得到迭代器对象
while (iterator.hasNext()){
System.out.println(iterator.next());
}
假设s1和s2是Set对象，下面的操作可实现相关的集合运算。
s1.addAll(s2)：实现集合s1与s2的并运算。
s1.retainAll(s2)：实现集合s1与s2的交运算。
s1.removeAll(s2)：实现集合s1与s2的差运算。
s1.containAll(s2)：如果s2是s1的子集，该方法返回true。
Comparator<？ super E> comparator()：返回与该有序集合相关的比较器，如果集合使用自然顺序则返回null。
boolean offer(E e)
如果可能立即在不违反容量限制的情况下这样做的话，将指定的元素插入到队列中。
一个Queue的实现类可能限制它所存放的元素的数量，这样的Queue称为受限队列。在java.util.concurrent包中的有些队列是受限的，而java.util包中的队列不是。
Queue接口的add()方法是从Collection接口继承的，它向队列中插入一个元素。如果队列的容量限制遭到破坏，它将抛出IllegalStateExcepion异常。offer()方法与add()方法的区别是在插入元素失败时返回false，它一般用在受限队列中。
boolean add(E e)
插入指定元素为该队列是否有可能立即这样做不违反容量限制，还 true成功后抛出 IllegalStateException如果没有空间是可用的。
E element()
检索，但不删除此队列的头。
boolean offer(E e)
如果可能立即在不违反容量限制的情况下这样做的话，将指定的元素插入到队列中。
E peek()
检索，但不删除，这个队列头，或返回 null如果队列为空。
E poll()
检索并移除此队列的头，或返回 null如果队列为空。
E remove()
检索和删除此队列的头。
集合转换：
public ArrayList(Collection c)
public HashSet(Collection c)
public LinkedList(Collection c)
在Map对象的键上迭代可以使用增强的for循环，也可以使用迭代器，如下所示：
for (KeyType key : m.keySet())
System.out.println(key);
如果使用迭代器，可通过下面方式实现：
for (Iterator<Type> i=m.keySet().iterator(); i.hasNext(); )
if (i.next().isBogus())
i.remove();
注意，Arrays.asList()方法返回的List对象是不可变的，如果对该List对象进行填加、删除等操作，将抛出UnsupportedOperationException异常。如果要实现对List对象的操作，可以将其作为一个参数传递给另一个List的构造方法，如下所示：
List<String> list = new ArrayList<> (Arrays.asList(str));
//Arrays.fill(Array[],i,i+1,val)有头无尾式
for(int i = 0;i < intArray.length;i++){
int num = (int)(Math.random()*90) + 10;
Arrays.fill(intArray, i, i + 1, num);
}
对线性表排序使用sort()方法，它有下面两种格式：
public static<T> void sort(List<T> list)
public static<T> void sort(List <T>list, Comparator<? super T> c)
该方法实现对List的元素按升序或指定的比较器顺序排序。该方法使用优化的归并排序算法，因此排序是快速的和稳定的
重排次序
使用shuffle()方法可以重排List对象中元素的次序，该方法格式为：
public static void shuffle(List<?> list)：使用默认的随机数重新排列List中的元素。
public static void shuffle(List<?> list, Random rnd)：使用指定的Random对象，重新排列List中的元素。
Collections类提供了5个对List对象的常规操作方法，如下所示。
public static void reverse(List<？> list)：该方法用来反转List中元素的顺序。
public static void fill(List<？ super T> list, T obj)：用指定的值覆盖List中原来的每个值，该方法主要用于对List进行重新初始化。
public static void copy(List<？super T> dest, List<？extends T> src)：该方法带有两个参数，目标List和源List。它实现将源List中的元素复制到目标List中并覆盖其中的元素。使用该方法要求目标List的元素个数不少于源List。如果目标List的元素个数多于源List，其余元素不受影响。
public static void swap(List<？> list, int i, int j)：交换List中指定位置的两个元素。
public static<T> boolean addAll(Collection<？ super T> c, T…elements)：该方法用于将指定的元素添加到集合c中，可以指定单个元素或数组。
frequency()方法可以返回指定元素在集合中出现的次数，使用disjoint()方法可以判断两个集合是否不相交。
public static int frequency(Collection<？> c, Object o)：返回指定的元素o在集合c中出现的次数。
public static boolean disjoint(Collection<？> c1, Collection<？> c2 )：如果两个集合不包含相同的元素，该方法返回true。
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的
java如何输入多行字符串：
str = str.replace("0", "");
str = str.replaceAll("[0]", "");
调用replace(),或replaceAll方法是不会改变str本身的！！
unsigned int 0～4294967295
int 2147483648～2147483647
unsigned long 0～4294967295
long 2147483648～2147483647
long long的最大值：9223372036854775807
long long的最小值：-9223372036854775808
unsigned long long的最大值：1844674407370955161
__int64的最大值：9223372036854775807
__int64的最小值：-9223372036854775808
unsigned __int64的最大值：18446744073709551615
k++和k+1是 不一样的
list.addAll(res);
Collections.sort(list);
如果是要设成缺省值如0，则java 中新开的数组本来就会全部初始化成缺省值的，主类型初始化为0，对象类型初始化为null，不用显示再去初始化了。
out:
for(int a = 0; a <= max; a++)
for(int b = a ; b <= max; b++)
for(int c = b; c <= max; c++){
int d = (int) Math.sqrt(N - a*a - b*b - c*c);
if(N == a*a + b*b + c*c + d*d){
System.out.println(a + " " + b + " " + c + " " + d);
break out;
vec.aad(index,elemen):是在index元素之前插入
int n=scanner.nextInt();
scanner.nextLine();
while ((n--)>0) {
String telphone=scanner.nextLine();
//
获取玩sc.nextInt()后面如果还需要获取sc.nextLine()的话，需要在nextInt()后面添加一句nextLine();
ArrayList<String> list=new ArrayList();
long startTime = System.currentTimeMillis(); // 程序开始时间
hanoi(i, 1, 2, 3);
long endTime = System.currentTimeMillis(); // 程序结束时间
BigDecimal bd = new BigDecimal(d).setScale(6,BigDecimal.ROUND_HALF_UP);
for (Iterator iterator = sets.iterator(); iterator.hasNext();) {
Set<Integer> set = (Set<Integer>) iterator.next();
for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
Integer integer = (Integer) iterator2.next();
System.out.print(integer);
if (iterator2.hasNext() == false) {
System.out.println();
} else {
System.out.print(" ");
}
}
}
迭代器输出：up
list:有序，有重复
直接输出一个数组：Arrays.toString(数组）
快速查找类：ctrol+shitf+t
java.lang.ClassCastException:java.lang.Long cannot be cast to java.lang.Integer:表示类型转换异常
mysql
1 内连接：
select * from t_customer c,t_linkman l where c.cid=l.clid
select * from t_customer c INNER JION t_linkman l ON c.cid=l.clid
2 左外连接：
select * FROM t_customer c LEFT OUTER JION t_linkman l ON c.cid=l.clid
3 右外连接
select * FROM t_customer c RIGHT OUTER JION t_linkman l ON c.cid=l.clid
动态磁盘不能装多系统
vector:动态容量
把String转换成Char数组 str.toCharArray()
new 一个set
Set<Character> set = new LinkedHashSet<Character>()
new 一个list
List list=new ArrayList();
List<Integer> list1=new ArrayList<Integer>();
把StringBuffer 清空 ： sb.setLength(0); // 清空
while(iter.hasNext()){
lis.add(iter.next());
}
SCSII表：A:65 Z:90
a:97 z:122
1:49
9:97
result.elementAt(4)-'0'
s.substring(0,2); substring方法是有头无尾的
Stack<Character> a = new Stack<Character>();
vector:add方法和remove()方法
//泛形要求能包容的是对象类型，而基本类型在java里不属于对象。但是基本类型都有其包装类型，也就是对象类型：
Stack<Integer> a = new Stack<Integer>();
a.push('}');
Stack.pop();
public E pop()
在这个堆栈的顶部删除对象，并返回该对象的值作为该函数的值。
stack.peek()
查看此堆栈顶部的对象，而不将它从堆栈中删除。
char[] x = n.toCharArray();
int a = x[0]-'0';
Stack<Character> a = new Stack<Character>();
List src = new Vctor();//这里实现了一边删除一边添加，因为是list，所以删除是删除前面的元素，但是添加是在最后添加的
src.add(src.remove(0));
//list
ArrayList<String> list=new ArrayList();
List dst = new Vector();
//s.substrin(1) substring是有头无尾，截取从第一元素开始到最后一个元素
return getFirstNum(s.substring(1)); // 填空
for(int j=i*3;j<i*3+3;j++){
//***************这里只要不满足三个一组，就会被逐个添加到list中，并且满足了3个一组的时候就会删除上一组
lis.get(i)[j%3] = s[j].toCharArray();
}
浮点数运算： System.out.printf("%.3f",sum/500000f);
关于IO：
File inFile = new File("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/test.java");
FileInputStream fileInputStream;
fileInputStream = new FileInputStream(inFile);
InputStreamReader inputStreamReader = new InputStreamReader(
fileInputStream);
BufferedReader bufferedReader = new BufferedReader(
inputStreamReader);
File outFile = new File("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/test.html");
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
OutputStreamWriter outStreamWriter = new OutputStreamWriter(
fileOutputStream);
BufferedWriter bufferedWriter = new BufferedWriter(outStreamWriter);
outStreamWriter.write("<html>\n");
关于IO2： // 定义读取内容
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 定义输出内容
PrintWriter pw = new PrintWriter("b.html");
String s;
pw.write("<html><body>\n");
while((s=br.readLine())!=null){
pw.write(process(s)); // 输出内容
}
pw.write("</body></html>");
br.close();
pw.close();
System.out.println("转换成功");
关于IO3：
public static void main(String[] args) throws Exception{
String value = "中国风\n";
String value2 = "a 中国风\n";
// 向文件中写入内容
PrintWriter pw = new PrintWriter("D:/MyEclipseworkspace/algorithm/src/pers/robert/lanqiaobeizhenti129/temp.txt","UTF-8");
pw.write(value);
pw.write(value2);
pw.close();
// 从文件中读取内容
BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream("temp.txt"),"utf-8"));
String b;
while((b = br.readLine())!=null){ // 按行读取
System.out.println(b);
}
br.close();
}
array[0]=true;
for (int i = 1; i <array.length; i++) {
array[i]=(i>=8&&!array[i-8])||(i>=7&&!array[i-7])||(i>=3&&!array[i-3])||(i>=1&&!array[i-1]);
}
//这里一般会添加一句这个，不然会出错
scanner.nextLine();
while((n--)>0){
for (int i = 0; i < s.length(); i++) {
array[i%6]+=(int)(s.charAt(i));
}
for(int[] x: t){
for(int y:x){
System.out.print(y+"\t");
}
System.out.println();
}
System.out.printf("%4d",array[i][j]);
for (int i = 0; i < pair.length(); i++) {
vector.remove((Character)pair.charAt(i));
array[i/5][i%5]=pair.charAt(i);
}
for (int i = 0,j=pair.length() ; i < vector.size()-1; i++,j++) {
array[j/5][j%5]=vector.elementAt(i);
}
ss[i++] = sb.substring(0,2);
sb.delete(0, 2);
String string=priorityBlockingQueue.poll();//poll() 检索并移除此队列的头，或返回 null如果队列为空。
Set<Set<Integer>>set=new LinkedHashSet<>();
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
iterator 无序，set也是无序的，arraylist是有序的
List<MyPoint> list = new ArrayList<MyPoint>();
List<Integer> lst = new Vector<Integer>();
lst.addAll(Arrays.asList(12, 127, 85, 66, 27, 34, 15, 344, 156, 344,
29, 47));
lst.set(i, a);
Rectangle()
构建了一种新的 Rectangle其左上角为（0， 0）在坐标空间，其宽度和高度均为零。
for (int i = len - 1; i > 0; i--) { // 当值等于3时，实现逢3进位
if (sign[i] == 3) {
sign[i] = 0; // sign[i] 归零
sign[i - 1]++; // sign[i-1]进位
}
}
这个比值四舍五入后已经达到了与0.618034一致的精度。
表示方法：if(Math.abs((double)a/b-0.618034)<0.000001){
System.out.println(a+"/"+b+" = "+(double)a/b);
break;
}
解决精度缺失问题：可以用BigDecimal对象
一般来说，可以使用BigDecimal的构造方法或者静态方法的valueOf()方法把基本类型的变量构建成BigDecimal对象。
1 BigDecimal b1 = new BigDecimal(Double.toString(0.48));
2 BigDecimal b2 = BigDecimal.valueOf(0.48);
对于常用的加，减，乘，除，BigDecimal类提供了相应的成员方法。
1 public BigDecimal add(BigDecimal value); //加法
2 public BigDecimal subtract(BigDecimal value); //减法
3 public BigDecimal multiply(BigDecimal value); //乘法
4 public BigDecimal divide(BigDecimal value); //除法
ROUND_HALF_UP: 遇到.5的情况时往上近似,例: 1.5 ->;2
ROUND_HALF_DOWN : 遇到.5的情况时往下近似,例: 1.5 ->;1
BigDecimal a = new BigDecimal(1.5);
System.out.println("down="+a.setScale(0,BigDecimal.ROUND_HALF_DOWN)+"/tup="+a.setScale(0,BigDecimal.ROUND_HALF_UP));
结果:down=1 up=2
看这个例子就明白了!
public static Date addDate(Date date,long day) throws ParseException {
long time = date.getTime(); // 得到指定日期的毫秒数
day = day*24*60*60*1000; // 要加上的天数转换成毫秒数
time+=day; // 相加得到新的毫秒数
return new Date(time); // 将毫秒数转换成日期
}
Set<Set<Integer>> sets = new LinkedHashSet<Set<Integer>>();
判断闰年：if ((year%4==0&&year%100!=0)||year%400==0) {
return 366;
}
//除掉序号能被2整除的
for(int i=vector.size()-1;i>=1;i--){
//巧妙的从后往前删
if(i%2==0){
vector.remove(i);
}
}
int i = (int) (Math.random() * 60);//填空
int[] temp = new int[]{i,j,k,m};
Arrays.sort(temp); // 排序
Set<Integer> sets = new HashSet<Integer>();
LinkedList<String> s
s.getFirst(); //返回第一个元素
s.removeLast();//删除最后一个元素
private Map map = new HashMap();
List<Character> t = (List<Character>) map.get(parent);
public BigInteger mod(BigInteger m)
返回一个BigInteger的价值 (this mod m）。
这种方法不同于 remainder，它总是返回一个非负BigInteger。
-100 mod 3 is 2
得到最大公约数： // 得到最大公约数(辗转相除)
public static BigInteger gdc(BigInteger m,BigInteger n) {
BigInteger r = m.mod(n);
while(r.compareTo(BigInteger.ZERO)!=0){
m = n;
n = r;
r = m.mod(n);
}
return n;
}
得到最小公倍数：
m = m.multiply(n).divide(gdc(m, n)); // 得到最小公倍数
int g = (n+7)/8; // 分组数 g 17人时，还是的跟3组，24人还是得分三组
但如果是16人可以分成两组，16+7/8=2.**，==int(2.**)==2
System.out.println("输入整数n");
int n = scan.nextInt();
scan.nextLine();
String[] s = new String[n];
for(int i=0;i<n;i++){
s[i] = scan.nextLine(); // 初始数据
}
ArrayList<String> lis = new ArrayList<String>(); // 记录全部交换结果(检查重复用)
Queue<String> queue = new LinkedList<String>(); // 队列(用来测试所有可能)
queue.offer(t); // 入队
lis.add(t); // 添加记录
手机百度页面搜索霍金动画
sb.insert(0, s).toString();
insert(index,s):在【index】元素后面添加s
System.out.println(new DecimalFormat(".00").format(s));
StringBuffer ss = new StringBuffer();
ss.setLength(0)//清空临时串
利用数组求BigInteger的加减乘除
LUCAS:C（n,m）%p=C(n/p,m/p)%p*(n%p,m%p)%p
熟练度：
arrays
public static int getNum(char c){
switch(c){
case 'I': return 1;
case 'V': return 5;
case 'X': return 10;
case 'L': return 50;
case 'C': return 100;
case 'D': return 500;
case 'M': return 1000;
}
return 0;
}
static HashMap<Character,Integer> Map =
new HashMap<Character,Integer>(){
{
put('I',1);
put('V',5);
put('X',10);
put('L',50);
put('C',100);
put('D',500);
put('M',1000);
}
};
汉字转化为数字的关键步骤：return (b[0]<<8&0xff00) + (b[1]&0xff); b
b = (""+c).getBytes("GB2312");
for (;;) {
if (a.size() == 1)
break;
for (int k = 0; k < 2; k++)
a.add(a.remove(0));// 填空
a.remove(0);
}
return reverseString(x.substring(1)) + x.charAt(0); // 填空
十进制与任意进制的互换：The112
负数在计算机中用补码表示，补码：原码取反+1
十进制负数-->二进制：绝对值十进制-->二进制，取反，+1
二进制负数-->十进制： 二进制-1，取反，计算得到十进制
(int) Math.sqrt(n):开根号
Math.abs(n):返回绝对值
Math.mod:求余
Pattern p=Pattern.compile("([0-9]+)");
Matcher m=p.matcher(s);
String fin="";
int st=0;
while(m.find()){//find方法扫描输入序列寻找匹配模式下的子序列
int start=m.start();
int end=m.end();
fin+=s.substring(st,start);
System.out.println("fin:"+fin);
if(s.charAt(start-1)!=' ')fin+="_";
System.out.println("fin:"+fin);
System.out.println(m.group(1));
fin+=m.group(1);
if(s.charAt(end)!=' ')fin+="_";
st=end;
}
m.group
String[] ss = s.split("[\\s]+"); //匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
ss[i] = sb.replace(0, 1, up).toString();
String num,num2;//直接替换字符串
ss[i] = ss[i].replace(num, num2);
if(ss[i].startsWith("_")){ // 去头"_"
ss[i] = ss[i].substring(1);
}
if(ss[i].endsWith("_")){ // 去尾"_"
ss[i] = ss[i].substring(0,ss[i].length()-1);
}
(char)('A'-1+n%26);
lis.add(Arrays.copyOf(n, n.length));
lis.add(n);
Arrays.sort(d); //排序
//该实现类需要自己实现一个继承了 Comparator 接口的类， 在插入资源时会按照自定义的排序规则来对资源数组进行排序。 其中值大的排在数组后面 ，取值时从数组投开始取
public static String elementOfPriorityBlockingQueue
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Integer integer2 = (Integer) iterator.next();
System.out.print(integer2);
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Integer integer2 = (Integer) iterator.next();
System.out.print(integer2);
2018年3月21日18:20:06
正则表达式：
1.元字符
. \d \D \s \S \w \W
2.限定符：
？ * + {n}正好n次 {n,m} {n,}至少出现n次
public String toString(int p) 返回当前大整数对象p进制的字符串表示
public BigInteger remainder(BigInteger val)返回当前大整数对象与参数指定的大整数对象的余。
。
例如：String s = String.format(“%.2f”,3.141592);那么s就是“3.14”.
String s=format("%d元%0.3f公斤%d台",888,999.777666,123); 那么,s就是"888元999.778公斤123台"。
String s=String.format(“不是从左向右：%2$.3f,%3$d,%1$d”,x,y,100);
字符串s就是 不是从左向右：3.142,100,888
注2：如果准备在“格式化模式”中包含普通的%，在编写代码时需要连续键入两个%，如：
String s=String.format("%d%%",89); 输字符串s是："89%"
1）%d，%o，%x和%格式符可格式化byte、Byte、short、Short、int、Integer、long和Long型数据
，详细说明见Page204. 例如，对于：
String s
= String.format("%d,%o,%x,%X",703576,703576,703576,703576);
字符串s就是：703576,2536130,abc58,ABC58
import java.util.regex.*;
public class Example8_22 {
public static void main(String args[ ]) {
String s = "市话76.8元,长途:167.38元,短信12.68";
String regex = "[0123456789.]+"; //匹配数字序列
Pattern p =Pattern.compile(regex); //模式对象
Matcher m =p.matcher(s); //匹配对象
double sum =0;
while(m.find()) {
String item = m.group();
System.out.println(item);
sum = sum+Double.parseDouble(item);
}
System.out.println("账单总价格:"+sum);
}
}
List<T> myList = new ArrayList<T>()
Iterator iterator = myList.iterator(); // 得到迭代器对象
while (iterator.hasNext()){
System.out.println(iterator.next());
}
假设s1和s2是Set对象，下面的操作可实现相关的集合运算。
s1.addAll(s2)：实现集合s1与s2的并运算。
s1.retainAll(s2)：实现集合s1与s2的交运算。
s1.removeAll(s2)：实现集合s1与s2的差运算。
s1.containAll(s2)：如果s2是s1的子集，该方法返回true。
Comparator<？ super E> comparator()：返回与该有序集合相关的比较器，如果集合使用自然顺序则返回null。
boolean offer(E e)
如果可能立即在不违反容量限制的情况下这样做的话，将指定的元素插入到队列中。
一个Queue的实现类可能限制它所存放的元素的数量，这样的Queue称为受限队列。在java.util.concurrent包中的有些队列是受限的，而java.util包中的队列不是。
Queue接口的add()方法是从Collection接口继承的，它向队列中插入一个元素。如果队列的容量限制遭到破坏，它将抛出IllegalStateExcepion异常。offer()方法与add()方法的区别是在插入元素失败时返回false，它一般用在受限队列中。
boolean add(E e)
插入指定元素为该队列是否有可能立即这样做不违反容量限制，还 true成功后抛出 IllegalStateException如果没有空间是可用的。
E element()
检索，但不删除此队列的头。
boolean offer(E e)
如果可能立即在不违反容量限制的情况下这样做的话，将指定的元素插入到队列中。
E peek()
检索，但不删除，这个队列头，或返回 null如果队列为空。
E poll()
检索并移除此队列的头，或返回 null如果队列为空。
E remove()
检索和删除此队列的头。
集合转换：
public ArrayList(Collection c)
public HashSet(Collection c)
public LinkedList(Collection c)
在Map对象的键上迭代可以使用增强的for循环，也可以使用迭代器，如下所示：
for (KeyType key : m.keySet())
System.out.println(key);
如果使用迭代器，可通过下面方式实现：
for (Iterator<Type> i=m.keySet().iterator(); i.hasNext(); )
if (i.next().isBogus())
i.remove();
注意，Arrays.asList()方法返回的List对象是不可变的，如果对该List对象进行填加、删除等操作，将抛出UnsupportedOperationException异常。如果要实现对List对象的操作，可以将其作为一个参数传递给另一个List的构造方法，如下所示：
List<String> list = new ArrayList<> (Arrays.asList(str));
//Arrays.fill(Array[],i,i+1,val)有头无尾式
for(int i = 0;i < intArray.length;i++){
int num = (int)(Math.random()*90) + 10;
Arrays.fill(intArray, i, i + 1, num);
}
对线性表排序使用sort()方法，它有下面两种格式：
public static<T> void sort(List<T> list)
public static<T> void sort(List <T>list, Comparator<? super T> c)
该方法实现对List的元素按升序或指定的比较器顺序排序。该方法使用优化的归并排序算法，因此排序是快速的和稳定的
重排次序
使用shuffle()方法可以重排List对象中元素的次序，该方法格式为：
public static void shuffle(List<?> list)：使用默认的随机数重新排列List中的元素。
public static void shuffle(List<?> list, Random rnd)：使用指定的Random对象，重新排列List中的元素。
Collections类提供了5个对List对象的常规操作方法，如下所示。
public static void reverse(List<？> list)：该方法用来反转List中元素的顺序。
public static void fill(List<？ super T> list, T obj)：用指定的值覆盖List中原来的每个值，该方法主要用于对List进行重新初始化。
public static void copy(List<？super T> dest, List<？extends T> src)：该方法带有两个参数，目标List和源List。它实现将源List中的元素复制到目标List中并覆盖其中的元素。使用该方法要求目标List的元素个数不少于源List。如果目标List的元素个数多于源List，其余元素不受影响。
public static void swap(List<？> list, int i, int j)：交换List中指定位置的两个元素。
public static<T> boolean addAll(Collection<？ super T> c, T…elements)：该方法用于将指定的元素添加到集合c中，可以指定单个元素或数组。
frequency()方法可以返回指定元素在集合中出现的次数，使用disjoint()方法可以判断两个集合是否不相交。
public static int frequency(Collection<？> c, Object o)：返回指定的元素o在集合c中出现的次数。
public static boolean disjoint(Collection<？> c1, Collection<？> c2 )：如果两个集合不包含相同的元素，该方法返回true。
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的
java如何输入多行字符串：
str = str.replace("0", "");
str = str.replaceAll("[0]", "");
调用replace(),或replaceAll方法是不会改变str本身的！！
unsigned int 0～4294967295
int 2147483648～2147483647
unsigned long 0～4294967295
long 2147483648～2147483647
long long的最大值：9223372036854775807
long long的最小值：-9223372036854775808
unsigned long long的最大值：1844674407370955161
__int64的最大值：9223372036854775807
__int64的最小值：-9223372036854775808
unsigned __int64的最大值：18446744073709551615
k++和k+1是 不一样的
list.addAll(res);
Collections.sort(list);
如果是要设成缺省值如0，则java 中新开的数组本来就会全部初始化成缺省值的，主类型初始化为0，对象类型初始化为null，不用显示再去初始化了。
out:
for(int a = 0; a <= max; a++)
for(int b = a ; b <= max; b++)
for(int c = b; c <= max; c++){
int d = (int) Math.sqrt(N - a*a - b*b - c*c);
if(N == a*a + b*b + c*c + d*d){
System.out.println(a + " " + b + " " + c + " " + d);
break out;
vec.aad(index,elemen):是在index元素之前插入
int n=scanner.nextInt();
scanner.nextLine();
while ((n--)>0) {
String telphone=scanner.nextLine();
//
获取玩sc.nextInt()后面如果还需要获取sc.nextLine()的话，需要在nextInt()后面添加一句nextLine();
ArrayList<String> list=new ArrayList();
long startTime = System.currentTimeMillis(); // 程序开始时间
hanoi(i, 1, 2, 3);
long endTime = System.currentTimeMillis(); // 程序结束时间
BigDecimal bd = new BigDecimal(d).setScale(6,BigDecimal.ROUND_HALF_UP);
for (Iterator iterator = sets.iterator(); iterator.hasNext();) {
Set<Integer> set = (Set<Integer>) iterator.next();
for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
Integer integer = (Integer) iterator2.next();
System.out.print(integer);
if (iterator2.hasNext() == false) {
System.out.println();
} else {
System.out.print(" ");
}
}
}
迭代器输出：up
扫一扫
246
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
