蓝桥总结

蓝桥总结

进制转换
1、Integer.toHexString(n) //十进制转十六进制
2、Integer.toOctalString(n) //十进制转八进制
3、Integer.toBinaryString(n)//十进制转二进制
String string=Integer.toString(a,3).toString();//十进制转任何进制
System.out.println(Integer.parseInt(“1010”,2));//任何进制转换为十进制

1、Integer.valueOf(n,16).toString() //十六转十
2、Integer.toOctalString(Integer.valueOf(n,16)) // 十六转八
3、Integer.toBinaryString(Integer.valueOf(n,16) //十六转二

1、Integer.valueOf(n,8).toString() //八转十
2、Integer.toHexString(Integer.valueOf(n,8)) 八转十六
3、 Integer.toBinaryString(Integer.valueOf(n,8))八转二

String类型int类型转换
常用
Int a=Integer.parseInt(string类型) //string 转int
String s=Integer.toString(int 类型) //int 转为string类型

String转换为int类型的方法：

1. Integer.parseInt([String])
   2.Integer.valueOf([String]).intValue();
   3.Integer.decode([String]):将 String 解码为 Integer。接受通过以下语法给出的十进制、十六进制和八进制数字
   例如：
   int a=Integer.decode(“0144”); //八进制转换结果为100
   int b=Integer.decode(“123”);//十进制转换结果为123
   int c=Integer.decode(“0x123”);//16进制转换结果为291
   注：Integer.decode([String])加负号也可以转换,不过字符串不能有空格。否则报NumberFormatException异常
   注: 字串转成 Double, Float, Long 的方法大同小异.

int转换为String类型方法：
1.String s = String.valueOf(i);
2.String s = Integer.toString(i);
3. String s = “” + i;
不常用的：
1.Integer.toBinaryString(int i) :以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
2.Integer.toHexString(int i) :以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
3.Integer.toOctalString(int i):以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
注: Double, Float, Long 转成字串的方法大同小异.
BigInteger大整数类型
因为BigInteger类型不是基本类型所以不能直接+ - * /
而要调用一些方法来代替
例如：
BigInteger a=new BigInteger(“2222222”);

BigInteger  b=new BigInteger("1111111");

String he=a.add(b).toString();

String  cha=a.subtract(b).toString();

String ji=a.multiply(b).toString();

String shang=a.divide(b).toString();

System.out.println(he );
System.out.println(cha);
System.out.println(ji);
System.out.println(shang);

总结一下BigInteger常为我们提供的方法

BigInteger abs() // 返回大整数的绝对值
BigInteger add(BigInteger val) //返回大整数的和
BigInteger and(BigInteger val) //返回大整数的按位与的结果
BigInteger andNot(BigInteger val) // 与非
BigInteger divide(BigInter val) // 返回两个大整数的商
BigInteger doubleValue() //返回大整数的double类型的值
BigInteger floatValue() //返回大整数的float类型的值
Biginteger gad(BigInteger val) //返回大整数的最大公约数
Int intValue()//返回大整数的整数值
Long langValue() //返回大整数的long值
BigInteger max/min/mod/multiply(BigInteger val) //返回大整数的最大值最小值 求模 相乘
BigInteger negate()//返回当前整数的相反shu
BigInteger pow(int n)//返回最大整数的n次方

栈
Stack()
1、boolean empty() //检测堆栈是否为空
2、object peek() //查看堆栈顶部的对象，并为此函数的值返回该对象
3、Object pop() //移除堆栈顶部的对象，并为此函数的值返回该对象
4、Object push(Object elenent) //把项压入堆栈顶部
5、int search(Object element) //返回对象在栈中的位置，以1为基数
迷宫算法
回溯算法
队列

位运算
| 相当于 并联
& 相当于 交
^ 相同为0不同为1
~ 取反 0变1 1变0
X<<n 左移运算符，每位向左移动n位 右边空缺补0
X>>n 右移运算符，每位向右移动n位 左边空缺补0
性质：
1、交换律
2、结合律 (a^b)c =a^(bc)
3、对于任何数x,都有x^x=0,x0=x
4、自反性 A^BB=A^0=A 消除

子数组求最大值
正数保留 负数丢弃（负数丢弃是从前到后丢弃）

位运算
与 &(相同为1 不同为0) 或|（相当于并 有1为1 ） 异或 ^（相同为0不同为1） 取反~ 左移 << 右移>>
1.6

奇偶数位交换

             1000011000与 1010101010做运算

1000011000&
1010101010
1000001000 //过程中 1起到保留偶数位的作用

1000011000与 0101010101做运算

1000011000&
0101010101
1000010000 过程中 1起到保留奇数位的作用

1000001000与1000010000
偶数右移一位 奇数左移一位

0100000100^
0000100000
0100100100

偶数左移一位 奇数右移一位 不成立

0000010000
0100001000
0100011000

第二章
递归
1、找重复 求n 的阶乘 à求n-1的阶乘
2、找变化
3、找边界 出口

第七章
Set(集合)：
Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。
Set接口主要实现了两个实现类：
HashSet : HashSet类按照哈希算法来存取集合中的对象，存取速度比较快
TreeSet : TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。
Set 的用法：
存放的是对象的引用，没有重复对象
Set set=new HashSet();
String s1=new String(“hello”);
String s2=s1;
String s3=new String(“world”);
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size());//打印集合中对象的数目 为 2。
Set 的 add()方法是如何判断对象是否已经存放在集合中？
boolean isExists=false;
Iterator iterator=set.iterator();
while(it.hasNext()) {
String oldStr=it.next();
if(newStr.equals(oldStr)){
isExists=true;
}
}

List(列表)：
List的特征是其元素以线性方式存储，集合中可以存放重复对象。
List接口主要实现类包括：
ArrayList() : 代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与
与删除元素的速度慢。
LinkedList(): 在实现中采用链表数据结构。插入和删除速度快，访问速度慢。
对于List的随机访问来说，就是只随机来检索位于特定位置的元素。
List 的 get(int index) 方法放回集合中由参数index指定的索引位置的对象，下标从“0” 开始。

数组的定义：
一维数组的定义和初始化
1、静态初始化
Int a[]={1,2,3,4};
2、动态初始化
Int a[]=new int[3];

二维数组
1、静态初始化
Int a[][]={{1,2},{3,4},{56}};
2、动态初始化
Int a[][]=new int[2][3]
Int [] a;
递归求法 找重复 找变化 找出口
1、 公式 这个没什么可说的，就是套公式
斐波那契数列
2、 划一刀
1、 求数组的和 划一刀
首先分析 重复 第一个加上后面一堆 然后一堆里的第一个加上后面一堆
然后 变化 第一个数的下彪在变化
出口 最后一个
2、 打印i-j
重复 打印第一个 和后面一堆 一堆里第一个和后面一堆
变化 数字i
抽口 最后一个
3、 阶乘
重复 n!=n*(n-1)! (n-1)!=(n-1)*(n-2)!
变化 n
出口 1
4、 字符串反转
重复 最后一个往前翻
变化 位置
出口 第一个
有时候就可以根据第一个或者第二个例子写出函数
冒泡排序的原理
就是循环求最大值排在最后面
选择排序的原理
就是i,j循环

第九章
方法 类 对象
https://www.runoob.com/java/java-object-classes.html
继承
Integer.valueOf
Integer.valueOf(s)把字符串s解析成Integer对象类型，返回的integer 可以调用对象中的方法。
ArrayList：
特点： 有序、不唯一
数据结构： Object数组
ArrayList：包装类
作用一：ArrayList是基于Object[]实现的，所以该只能装引用数据类型，基本数类型要想装进集合，需要将基本数据类型进行类的包装。
作用二：包装类中有将String类型转换为对应的基本数据类型的方法。ArrayList的基本用法和特点
特点：
有序的：按照添加的顺序
不唯一：同一个元素可以装多次
1:如何创建泛型对象
ArrayList<泛型> list=new ArrayList<>();

2:如何添加元素：
一次添加一个元素：
list.add(元素);
一次添加多个元素：
Collections.addAll(集合，元素，元素，…);
3:得到集合元素的个数
list.size();
4:得到某一个元素
list.get(下标);
5：如何判断集合里面是否出现指定元素
list.contains();
HashMap
1.创建HashMap对象
HashMap<String, String> map = new HashMap<String, String>();
1.线程不安全的哈希表
2.键值对可以存储null，key不可以重复，value可以重复，重复时覆盖oldVlue
3.取出的数据没有顺序。
2.添加键值对
put方法添加元素时，如果key已经存在，则更新value的值。
存储的key和value都可以为null。
HashMap<String, String> map = new HashMap<String, String>();
map.put(“北京”, “key存在的oldValue”);
map.put(“上海”, null);
map.put(“广州”, “oldValue”);
map.put(null, “null的oldValue”);
map.putIfAbsent(null, “null的newValue”);
map.putIfAbsent(“杭州”, “key不存在的value”);
map.putIfAbsent(“北京”, “key存在的newValue”);
map.putIfAbsent(“上海”, “null值被覆盖”);
map.replace(“广州”, “replaceValue”);
map.replace(“武汉”, "key不存在的value
replace(key,value);
当key存在时，调用replace方法，会替换value。当key不存在，返回null
3.获取元素
1.get（key）获取HashMap的value
String valueStr=map.get(“北京”);
2.遍历map.keySet获取HashMap的key
1.ForEach迭代key
for (String key : map.keySet()) {
System.out.println("key= "+ key + “:” + map.get(key));
}
2.删除元素
remove(key)；存在key返回对应的value，否则返回null
remove(key,value);存在key-value，返回true。否则返回false
HashSet
HashSet中只能存储不能重复的对象，如果重复了程序不会出错，但是后面的内容会覆盖前面的（其实也看不出来谁覆盖谁，但是再map中能明显体会到）
首先定义一个HashSet HashSet set = new HashSet();说明一下，我这里的AnimalSet是一个定义的一个宠物的类（因为这样能更好的展现HashSet的基本用法）这里需要引入的包是import java.util.HashSet;
因为我的AnimalSet是一个类，所以我得先实例化一个对象AnimalSet one = new AnimalSet(“AA”,12,“AAA”);
· 增
set.add(one);set.add(two);
· 删
删除一个元素使用到的是set.remove(one);
Set集合的特点：
不能存储相同的元素。
Sr.No.
Method & Description
1
add( ) 向集合中添加元素
2
clear( ) 去掉集合中所有的元素
3
contains( ) 判断集合中是否包含某一个元素
4
isEmpty( ) 判断集合是否为空
5
iterator( ) 主要用于递归集合，返回一个Iterator()对象
6
remove( ) 从集合中去掉特定的对象
7
size( ) 返回集合的大小

同时因为其是一个抽象的接口：所以不能直接实例化一个set对象。(Set s = new Set() )错误
该接口主要继承于Collections接口，所以具有Collection的一些常见的方法。
常见的方法：

Set接口最长用的两大实现：HashSet TreeSet
队列
ArrayDeque q = new ArrayDeque<>();
Queue： 是一个队列，即一个先入先出（FIFO）的数据结构
Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。
1、add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
　2、　remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
　3、　element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
　4、　offer 添加一个元素并返回true 如果队列已满，则返回false

5、　poll 移除并返问队列头部的元素 如果队列为空，则返回null
　　6、peek 返回队列头部的元素 如果队列为空，则返回null
　　7、put 添加一个元素 如果队列满，则阻塞
　　8、take 移除并返回队列头部的元素 如果队列为空，则阻塞
Pop 头元素
StringBuffer bf = new StringBuffer();//用变长字符串存储最终路径
bf.append(dir[i]);//把走的方向存储
while(A||B)
只要满足A或者B中的其中一项，即认为他是对的。
substring(参数)是java截取字符串的一个方法。
它有两种传参的方式：
第一种：public String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串，该字符串从指定索引出的字符开始，到此字符串末尾结束。
第二种：public String substring(int beginIndex,int endIndex)
同样返回一个新的字符串，该字符串从指定的beginIndex索引处开始，到指定的endIndex索引值结束。
public String substring(int beginIndex)
这个方法截取的字符串是从索引beginIndex开始的，到整个字符串的末尾，例如：字符串String s = “abcdef”;
调用s.substring(2)表示从字符串的索引2开始截取到整个字符串结束，截取的字符串为cdef

不包括endIndex索引处的字符。
所以，该字符串的长度就是endIndex-beginIndex。
广搜 唯一解 最短路径
深搜 多个解 多少条路
对于深度优先（dfs）和广度优先(bfs)
深度有点执拗他会一直走下去不通就会回来再走 求出所有的解
广度则不同 它走遍所有 不会重复走 所以很适合来求最段路径问题
动规是对递归的修剪
下标的问题
求一个字符串的下标
Int a=string.indexof(“BOB”);
//求字符串string中BoB的第一个下标；
求其他BOB的下
int b=Integer.indexof(“B0B”,a+1)
迷宫问题我所犯得错误
首先是输入问题
应该一行一行的输入
用while循环来继续每一步
Bfs函数是用来计算每一个点到（m,n）的距离的
然后再main函数里 往前走
其中要注意的是 while循环里 从（0，0）走到终点往后数一步
next()和nextLine()的区别详解
/*next()方法在读取内容时，会过滤掉有效字符前面的无效字符，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其过滤掉；只有在读取到有效字符之后，next()方法才将其后的空格键、Tab键或Enter键等视为结束符；所以next()方法不能得到带空格的字符串。
*/
/*nextLine()方法字面上有扫描一整行的意思，它的结束符只能是Enter键，即nextLine()方法返回的是Enter键之前没有被读取的所有字符，它是可以得到带空格的字符串的。
*/
StringBuffer bf = new StringBuffer();//用变长字符串存储
一个字符串的反转
String reversal=new StringBuilder(s).reverse().toString();

String s1 = “abc”;
String s2 = “abcd”;
String s3 = “abcdfg”;
String s4 = “1bcdfg”;
String s5 = “cdfg”;
System.out.println( s1.compareTo(s2) ); // -1 (前面相等,s1字符串长度小1)
System.out.println( s1.compareTo(s3) ); // -3 (前面相等,s1字符串长度小3)
System.out.println( s1.compareTo(s4) ); // 48 ("a"的ASCII码是97,"1"的的ASCII码是49,所以返回48)
System.out.println( s1.compareTo(s5) ); // -2 ("a"的ASCII码是97,"c"的ASCII码是99,所以返回-2)
Comparable接口
1：所有可以 “排序” 的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法。
2：public int compareTo(Object obj) ;
该方法：
返回 0 表示 this == obj
返回整数表示 this > obj
返回负数表示 this < obj
3:实现了 Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。

列表
List list=new ArrayList<>();
Collections.sort(list);
//对list进行排序

把几行字符串转换为二维数组的两种方法
把int类型转换为数组
for (int i = 0; i < 30; i++) {
String s = sc.nextLine();
for (int j = 0; j < 50; j++) {
map[i][j] = s.charAt(j) - ‘0’;
}
}

把string类型转换为char类型的二维数组
for (int i = 0; i <N; i++) {
sore[i]=scanner.next().toCharArray();
}

递归 1、与n相关
2、与n-1 或者n-2或者n-3有关