蓝桥杯复习笔记20180304

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

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

蓝桥杯复习笔记20180304相关推荐

【蓝桥杯学习笔记】9. 解立方根——二分法+牛顿迭代法
系列文章目录 [蓝桥杯学习笔记]1. 入门基本语法及练习题 [蓝桥杯学习笔记]2. 常用模型----最大公约数和最小公倍数 [蓝桥杯学习笔记]3. 质数判断 [蓝桥杯学习笔记]5. 矩阵乘法 [蓝桥杯 ...
辣椒的蓝桥杯复习之旅
/*大一新生用来纪念自己第一次竞赛复习,大佬勿喷*/ /* DATA: 2023.4.1 */ 基础算法: 1.快速排序(递归.归并) #include<bits/stdc++.h> in ...
【蓝桥杯单片机笔记】蓝桥杯备赛资料
资料目录资料都是来源自网络,侵删下载链接提取码:01xh 蓝桥杯必背 sfr AUXR = 0x8e; sfr P4=0xC0; //矩阵键盘 DS18B20 可添加到main函数里面 void ...
蓝桥杯学习笔记--工厂灯光控制系统（小蜜蜂笔记作业）
文章目录前言一.功能要求 1.功能图二.硬件分析 1.功能一硬件电路: 2.功能二硬件电路: 3.功能三硬件电路: 4.功能四硬件电路: 三.代码 1.整体流程(主函数) 2.138选择函数与关 ...
【国六总结】蓝桥杯复习资料（含外设代码）
瞎叨叨喜报:十三届国赛300块买了个3XL抹布! 这次属实是被套路了,确实可以不用拓展版,但就是调试麻烦. 今年是最后一年参加蓝桥杯了,走出考场
蓝桥杯学习笔记三：Delay函数毫秒变微秒
平时的HAL_Delay()都是毫秒单位的,但是进去这个函数看看的话,也看不出来是咋回事,我也不理解.但是就说在网上知道了一个方法:用SysTick_Config();这个函数就是来控制Delay函数 ...
蓝桥杯比赛笔记1（12.6）
python环境:3.8.6 IDLE(Python自带编译器)不是pycharm,vscode 对于编程大题,会有测试多组输入输出,测试通过的越多,分越高.20%-40%是弱测试数据,其他的是强测试 ...
蓝桥杯JAVA-32.二维数组（矩阵）实现旋转模板（JAVA实现）
个人博客 www.tothefor.com 蓝桥杯复习知识点汇总目录顺时针旋转 90° import java.io.*; import java.math.BigInteger; import ...
蓝桥杯2013年第四届C++B组省赛真题
蓝桥杯由于最近正在准备蓝桥杯的比赛,打算把这几年的真题做做,正好把蓝桥杯的笔记也发出来,方便以后自己查看笔记,也欢迎大家批评指正错误 2013年第四届C++B组省赛真题高斯日记题目描述大数学家 ...

蓝桥杯复习笔记20180304

蓝桥杯复习笔记20180304相关推荐

最新文章

热门文章