目录
^判断是否两边相同
byte一个字节8位
short类型
- 大小 ：
short类型占用2个字节（16位）的内存空间。int:
- 大小 ：
int类型占用4个字节（32位）的内存空间。long:8个字节 64位
- 大小:long类型占用8字节(64位)内存空间
float:32位
double:64位
3.4默认是double类型，不能给float赋值
char的底层是unicode,unicode是包含中文的
&&和&的区别，
&&左边得到结果，不会计算右边
&不论左边如何，都会计算右边
标识符:
字母,数字,下划线，美元符号
首位不能是数字
区分大小写
不能是关键字和保留字、首位不可以是数字，区分大小写
变量,数据类型，运算:变量和常量，标识符，编码规范
三元: ? :
两个数字n,m
假如交换可以进行n+m,然后操作n-m,m-n之类的操作。
二进制:
对于数据的保存都是采用二进制
规则:0，1
<<左移n位，等价乘以2的n次幂
>>,>>>右移，无符号右移，等价除以2的n次幂a
switch支持的数据类型，int,byte,short,char String,enum
case后面跟常量，必须是唯一常量
switch中break作用的中断，假如不去中断，则后面不会进行判断，而是一直去执行
思维：语义化，借助常量
比如定义男女
使用boolean
开始先用两个常量
final boolean MAN=true;
final boolean WOMAN=false;后面定义的时候，就可以比如boolean a=MAN;作为这个语义化
8个小球，一个比较重，其余一样，如何称两次找到重的
分为3，3，2组，把3个，3个两个比较，哪个重，其余就容易
一个5L杯子，一个3L杯子，怎么称4L的水
5L倒满，给3L,此时还剩2L，然后把3L杯子水倒没，把2L给3L水杯，之后，5L加满，给3L直到填满，此时剩4L.
力扣.H指数
class Solution {
public int hIndex(int[] citations) {
int h=0;
int n=citations.length;
Arrays.sort(citations);
// 0,0,0,1,2,3,5,6
h=0;
int i=n-1;
while(i>=0&&citations[i]>h){
//假如cit[i]当前位置比h大，就说明当前位置至少是H+1次，所以，需要h进行++;
h++;
i--;
}
return h;
}
}力扣.字母异位词
这个我思路是不明确的，想到了排序，但是假如我写，肯定没有这么便捷，
他的思路是，不管你什么异位词，我排序之后，你的所有异位词长的都是一个样子，所以我只需要让你所有的都进行排序，拿排序好的那个，作为key,因为假如是异位词，他排序之后的单词应该是一致的，因此这个作为key,然后List来去存储。
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
Map<String,List<String>>map=new HashMap<String,List<String>>();
for(int i=0;i<strs.length;i++){
char[]array=strs[i];
Arrays.sort(array);
String key=new String(array);
//不用判断是否相同，get(获取这个key)假如获取到了就返回,没获取到就new一个，反正这个一定是属于这个字符串的
List<String>list=map.getOrDefault(key,new ArrayList<String>);
list.add(strs[i]);
map.put(key,list);
}
}
}力扣.289生命游戏
这个生命游戏是很牛马的一个题目，俺以为他会一直变化，没想到只变化一层，他是一层之后，我们进行第一层，然后根据前面的那些变化，为什么要设置2和-1这俩个状态表示原先死了变活和原先活着变死了，是因为我们更改的同时，需要的是第一波的状态，我们需要得到原先是0还是1，其余就是正常了。
class Solution {
public void gameOfLife(int[][] board) {
int[] neighbors = {0, 1, -1};
int rows = board.length;
int cols = board[0].length;
// 遍历面板每一个格子里的细胞
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
// 对于每一个细胞统计其八个相邻位置里的活细胞数量
int liveNeighbors = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
//0，1，-1
if (!(neighbors[i] == 0 && neighbors[j] == 0)) {
// 相邻位置的坐标
int r = (row + neighbors[i]);
int c = (col + neighbors[j]);
//这步之前是来统计当前坐标的8个方位，然后把这个点除了本身，全部给处理掉，每个点都统计一下
//-1表示过去是活的，现在死了，2表示过去死了，现在活了
//r和c要在合法范围内 查看相邻的细胞是否是活细胞
if ((r < rows && r >= 0) && (c < cols && c >= 0) && (Math.abs(board[r][c]) == 1)) {
liveNeighbors += 1;
}
}
}
}
// 规则 1 或规则 3
if ((board[row][col] == 1) && (liveNeighbors < 2 || liveNeighbors > 3)) {
// -1 代表这个细胞过去是活的现在死了
board[row][col] = -1;
}
// 规则 4
if (board[row][col] == 0 && liveNeighbors == 3) {
// 2 代表这个细胞过去是死的现在活了
board[row][col] = 2;
}
}
}
// 遍历 board 得到一次更新后的状态
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
if (board[row][col] > 0) {
board[row][col] = 1;
} else {
board[row][col] = 0;
}
}
}
}
}力扣.86分隔链表
链表多多利用头节点，要舍得定义变量。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode partition(ListNode head, int x) {
ListNode preHead = new ListNode();
preHead.next = head;
ListNode cur = head;
// 4,3,2,5,2 此时没有找到我的pre
ListNode pre = preHead;
ListNode key = head;
while (cur != null) {
if (cur.val >= x) {
key = cur;
cur = cur.next;
break;
}
pre = cur;
cur = cur.next;
}
//相当于找到了所有比他小的节点的后一个节点，我此时还需一个比他小的节点的前一个节点
ListNode Precur=key;
//此时比他小的开头节点是pre,比他大的节点是key，我只需要往下找，假如比他小的，插入二者之间即可 1243
while (cur != null) {
if (cur.val < x) {
ListNode next = cur.next;
pre.next = cur;
cur.next = key;
pre = pre.next;
Precur.next=next;
cur = next;
} else {
Precur=cur;
cur = cur.next;
}
}
return preHead.next;
}
}