- 博客(49)
- 收藏
- 关注
RSS订阅原创 Bundle可以传输的数据有哪些
之前明明复习过，结果忘记了，面试的时候只根据实际使用说了String和基本数据类型，后来就说记不太清楚了，之后查了之后也可以传输实现Serializable或Parcelable接口的对象项目中页面用的fragment，所以两个fragment之间使用了bundle传递数据，数据内容基本都是string类型和int类型，没有很在意这个问题，后期查询，翻了之前总结的面经里面有提到bundle传递的数据类型：string，基本数据类型，和实现serializable或Parcelable接口的对象- 实现s
2021-03-24 15:15:31
749
1
原创 原来handler的MessageQueue的底层居然不是队列，而是单链表…
今天面试官问我，messageQueue的底层是什么，我就脱口而出是队列，每次都从头取走msg，就真的以为是先进先出的队列，面试官还反问我，再想一下，是队列还是链表，然后我说不是队列吗，他让我下去再看一下boolean enqueueMessage(Message msg, long when) { ... ...//省略 synchronized (this) { if (mQuitting) {//如果中止了，直接返回
2021-03-24 14:52:25
1241
1
原创 java设计模式--建造者模式
集合起来创建复合对象–某个类具有不同的属性以构造一个汽车为例车的抽象类abstract class builder{ //假设一辆车 车的抽象类 //车轮 public abstract void buildWheel(); //汽油 public abstract void buildOil(); //螺丝 public abstract void buildScrew(); //获得车 public abstract
2021-03-23 20:22:39
96
原创 java设计模式--工厂模式
1. 工厂方法模式结合代码来看普通工厂模式 对接口的方法进行实现的不同的类interface Sender{ void send(); }class ASender implements Sender{ //实现同一个接口的一个类 public void send(){//实现接口中的抽象方法 System.out.print("A Sender……"); }}class BSender implements Sender{/
2021-03-23 19:37:56
72
原创 java设计模式--单例模式
1. 单例模式普通懒汉模式//懒汉模式--线程不安全的public class Singleton { private static Singleton instance=null; private Singleton(){};//私有构造函数 public static Singleton getInstance(){ //线程不安全的 if(instance==null){ instance=new Singlet
2021-03-23 18:46:02
64
原创 leetcode 【排序】逆序找到规律一定满足
class Solution { public void wiggleSort(int[] nums) { int[] help = nums.clone(); //不能写成int[] help = nums,排序后两个数组都改变 Arrays.sort(help); int N = nums.length; //比如123456 逆序一定成立，即使遇到相同的数字 for (int i = 1; i < nums.
2021-03-19 20:22:56
79
原创 leetcode【排序】上一个那么难，这一个好简单…
class Solution { public boolean canMakeArithmeticProgression(int[] arr) { Arrays.sort(arr); int cha=arr[1]-arr[0]; int i=0; while(i<arr.length-1){ if(arr[i+1]==arr[i]+cha){ i++; }else{ return .
2021-03-19 20:04:51
66
原创 leetcode这个好难想，绕来绕去的
使用一个数组map来存储pieces信息，遍历pieces，将每个piece的第一个值作为数组map的index，piece在pieces中的index作为数组map对应的值。（因为 1 <= arr[i], pieces[i][j] <= 100，所以数组map的大小为101即可。并将有值初始化为 -1，方便后面判断）遍历原数组arr，根据arr[i]从map里找到对应的piece，若找不到（即map[arr[i]] == -1），直接返回false；找到，则遍历piece（从1开始遍历，.
2021-03-19 19:53:25
91
原创 leetcode【排序】又用到桶排序了，之前真没用过
桶排序，每个桶记录每个字母 class Solution { public String sortString(String s) { //相当于26个桶 int[] bucket = new int[26]; char[] charArr = s.toCharArray(); //把s中的字符分别放到对应的桶里 for (char c : charArr) { bucket[c - .
2021-03-19 18:26:23
76
原创 leetcode 【排序】跟上一道很像，只不过不能重复，所以很容易想到hashset去重
class Solution { public int[] intersection(int[] nums1, int[] nums2) { int length1=nums1.length; int length2=nums2.length; Arrays.sort(nums1); Arrays.sort(nums2); Set<Integer>set=new HashSet<>(); int i=0,j=0;// .
2021-03-19 16:17:57
53
原创 leetcode【排序】排序＋双指针找交集
class Solution { public int[] intersect(int[] nums1, int[] nums2) { Arrays.sort(nums1); Arrays.sort(nums2); int length1=nums1.length,length2=nums2.length; ArrayList<Integer> list=new ArrayList<>(); //双指针 int i.
2021-03-18 20:10:49
52
原创 leetcode【排序】贪心＋排序
class Solution { public int largestPerimeter(int[] nums) { //贪心＋排序 //认为选中的最大的三个数字就是可以组成三角形 Arrays.sort(nums); int length=nums.length; for(int i=length-1;i>=2;i--){ if(nums[i-2]+nums[i-1]>nums[.
2021-03-18 19:55:17
83
原创 leetcode这道题还挺有意思，有的用了桶排序
第一个想到的就是一层层遍历class Solution { public int[][] allCellsDistOrder(int R, int C, int r0, int c0) { int[][] result=new int[R*C][2]; int index=0; boolean[][] visited=new boolean[R][C];//是否访问 Queue<int[]> queue=new L.
2021-03-18 19:42:42
80
原创 leetcode【排序】这个自定义排序的比较器感觉不好直接想出来，需要多练欸
自定义排序，Collections.sort()介绍Collections.sort()class Solution { public int[] relativeSortArray(int[] arr1, int[] arr2) { //进行一个自定义排序 Map<Integer, Integer> map = new HashMap<>(); List<Integer> list = new ArrayLi.
2021-03-18 18:12:09
84
原创 leetcode【排序】维护两个双指针进行原地交换，奇数偶数数量相同
很容易想到维护两个双指针，当然暴力也可以做，只不过内存消耗和时间都很高，双指针进行原地交换很方便//双指针class Solution { public int[] sortArrayByParityII(int[] A) { int length = A.length; int j = 1; for (int i = 0; i < length; i += 2) { if (A[i] % 2 == 1) { //奇.
2021-03-16 18:15:49
105
原创 leetcode【排序】关键是用到了一个基本不常用的方法 Integer.bitCount()
bitCount实现的功能是计算一个（byte,short,char,int统一按照int方法计算）int,long类型的数值在二进制下“1”的数量class Solution { public int[] sortByBits(int[] arr) { for (int i = 0; i < arr.length; i++) { arr[i] += Integer.bitCount(arr[i]) * 100000; //bit.
2021-03-16 17:12:58
51
原创 leetcode【排序】开始排序的简单部分了，这个应该会快一点，今天了解了异位词
原来异位词是这个意思啊，是我孤陋寡闻了（排序后一模一样class Solution { public boolean isAnagram(String s, String t) { //t是不是s的，判断第一个 char S[]=s.toCharArray(); char T[]=t.toCharArray(); if(s.length()!=t.length()){ return false; }else{.
2021-03-16 16:57:26
44
原创 leetcode【贪心算法】最后一道题真的好简单哪
class Solution { public int numWaterBottles(int numBottles, int numExchange) { int maxdrunk=numBottles; int bottles=numBottles; //空瓶数量 while(bottles>=numExchange){ //这个时候能够再换 bottles-=numExchange; //喝numExchange瓶再用空的换一瓶 .
2021-03-15 18:01:47
49
原创 leetcode【贪心算法】这里用到了java8的API（真的简便
class Solution { public int robotSim(int[] commands, int[][] obstacles) { int dx[] = {0,1,0,-1}; int dy[] = {1,0,-1,0}; // 北 东 南 西 // 0 1 2 3 //-2 i+3 //-1 i+1 //set去重 Set&l..
2021-03-15 17:31:51
166
原创 leetcode【贪心算法】好幸福，遇到一道非常常规的贪心题目
达到局部最优，每次得到平衡子串的时候就断开class Solution { public int balancedStringSplit(String s) { int res=0;//记录结果 int i=0; int Rnum=0,Lnum=0; while(i<s.length()){ if(s.charAt(i)=='R'){ Rnum++; } if(s.cha.
2021-03-15 16:16:37
37
原创 leetcode【贪心算法】出现了一道一目了然的题目了
class Solution { public int countGoodRectangles(int[][] rectangles) { int length=rectangles.length; int []len=new int[length]; for(int i=0;i<length;i++){ len[i]=Math.min(rectangles[i][0],rectangles[i][1]); } //得到每个能切割的最大正方形边长.
2021-03-15 16:05:01
107
原创 leetcode【贪心算法】有点像在数学中的转换公式，两个变量建立联系保证最后只有一个变量进行控制
其实是前后两个部分的比较，但要保证两个部分的和是总和，建立两个部分的一个联系，前面部分=总和-后面的部分，总和一定，这样便通过一个变量建立了二者的联系class Solution { public List<Integer> minSubsequence(int[] nums) { int sum = 0; for(int n:nums){ sum += n; } Arrays.sort(nums.
2021-03-15 15:38:17
115
原创 leetcode【贪心算法】将数轴画出来模拟移动的可能会更加直观
//其实是在计算奇数个数和偶数个数中下、最小的那个//不同偶数位置的筹码都可以通过平移来到同一个偶数位置上//同上 奇数也是这样，最后其实就是一个奇数位置的数量和一个偶数位置的数量的比较class Solution { public int minCostToMoveChips(int[] position) { //其实是在计算奇数个数和偶数个数中下、最小的那个 //不同偶数位置的筹码都可以通过平移来到同一个偶数位置上 //同上 奇数也是这样，最后其实就.
2021-03-15 14:48:03
197
原创 leetcode 【贪心算法】不是很明显，其实就是极端讨论两种情况
class Solution { public int minOperations(String s) { int cnt1 = 0, cnt2 = 0; //cnt1代表变成010101需要改变几个 //cnt2代表变成101010需要改变几个 for (int i = 0; i < s.length(); i++) { if(i % 2 == 0){ if(s.char.
2021-03-13 20:15:30
69
原创 leetcode【贪心算法】重点是比较器的使用
这道题的思路非常简单，排序重量，以最大的开始加入** 比较器是把集合或数组的元素强行按照指定方法进行排序的对象，它是实现了Comparator接口类的实例。如果一个集合元素是可比较的（实现了Comparable接口），那么就具有了默认排序方法，比较器则是强行改变它默认的比较方式来进行排序。**class Solution { public int maximumUnits(int[][] boxTypes, int truckSize) { Arr.
2021-03-13 19:32:18
113
原创 leetcode【贪心算法】K次取反后得到最大和 （可重复
class Solution { public int largestSumAfterKNegations(int[] A, int K) { Arrays.sort(A);//排序 int sum=0;//记录最后的结果 for(int i=0;i<A.length;i++){ if(A[i]<0 && K>0){ A[i]=-A[i]; K-.
2021-03-13 17:29:31
73
原创 leetcode【贪心算法】买柠檬水 感觉在讨论所有情况
class Solution { public boolean lemonadeChange(int[] bills) { //维护5美元和10美元的数量 int five = 0, ten = 0; for (int bill : bills) { if (bill == 5) { five++; } else if (bill == 10) { .
2021-03-11 22:37:56
66
原创 leetcode 这算贪心吗，感觉像分情况讨论
class Solution { public String maximumTime(String time) { char h1=time.charAt(0); char h2=time.charAt(1); char m1=time.charAt(3); char m2=time.charAt(4); StringBuilder result=new StringBuilder(); // 当h.
2021-03-11 22:09:17
48
原创 leetcode【贪心算法】这里用了优先队列来计算（每次都进行排序效率太低了
class Solution { //最大堆 public int lastStoneWeight(int[] stones) { //优先队列 PriorityQueue<Integer> pq = new PriorityQueue<Integer>((a, b) -> b - a); //自定义了比较器，以上是lamda表达式 /*这是平常表达 PriorityQueue...
2021-03-10 18:25:20
151
原创 leetcode【贪心算法】也不知道怎么分到贪心的，明明是遍历
class Solution { public int minDeletionSize(String[] strs) { int res=0; for(int j=0;j<strs[0].length();j++){ for(int i=1;i<strs.length;i++){ if(strs[i-1].charAt(j)>strs[i].charAt(j)){ res++.
2021-03-10 17:42:57
85
原创 leetcode【贪心算法】 简单部分 分割字符串
class Solution { public boolean checkOnesSegment(String s) { String[] a = s.split("0"); return a.length==1;}}第二种解法，以01进行判断class Solution { public boolean checkOnesSegment(String s) { int n = s.length(), cnt = 0;//指针位置 f.
2021-03-10 17:22:44
95
原创 leetcode【贪心算法】简单部分
class Solution { public boolean canPlaceFlowers(int[] flowerbed, int n) { int i = 0; //题干里的要求就是花的旁边不能有花，所以一旦出现1则它的左右一格一定都是无法种花的0，所以直接跳过，只要看下一格格子是不是1或者到达终点。 while (i < flowerbed.length) { if (flowerbed[i] .
2021-03-09 22:16:19
37
原创 leetcode 【贪心算法】
以下算是数学求解观点就是，进行分割class Solution { public int totalMoney(int n) { int m=n/7; int sum1;//完整的部分 if(m==0){ sum1=0; }else{ int count2=m-1; int sum3=0;//多余的部分 while(count2>0){ sum3+=count2*7; count2--; .
2021-03-09 20:29:09
32
原创 leetcode 【贪心算法】简单部分（放弃动态规划的中等部分了，太难了
class Solution { public int findContentChildren(int[] g, int[] s) { Arrays.sort(g); Arrays.sort(s); int res=0; int i=0,j=0; while(i<g.length && j<s.length){ if(s[j]>=g[i]){ .
2021-03-09 19:58:36
101
原创 leetcode 【动态规划】中等部分 为什么感觉中等都这么难了（数学变差了
class Solution { public int minSteps(int n) { if (n == 1) return 0; int[] dp = new int[n + 1]; for (int i = 2; i <= n; i++) { dp[i] = i; int sqrt = (int) Math.sqrt(i);// 平方根向下取整 找到最小质数 fo.
2021-03-09 18:32:54
174
原创 leetcode 【动态规划】经典的最大子数组和
class Solution { public int maxSubArray(int[] nums) { int[] dp = new int[nums.length]; dp[0] = nums[0]; int max = dp[0]; for(int i=1;i < nums.length;i++){ dp[i] = Math.max(dp[i-1] + nums[i],nums[i]); .
2021-03-08 16:17:49
45
原创 leeetcode 【动态规划】简单部分 注意取模问题
第一种：消耗内存比较大但是最直观的解法class Solution { public int waysToStep(int n) { //最后一步走1阶 2阶 3阶 //dp[i]=dp[i-1]+dp[i-2]+dp[i-3]; if(n==1)return 1; if(n==2)return 2; if(n==3)return 4; long dp[]=new long [n+1]; dp[1]=1; dp[2]=2; .
2021-03-08 14:17:14
281
原创 leetcode【动态规划】 经典解题
第一种基本解法public class Solution { public int massage(int[] nums) { int len = nums.length; if (len == 0) { return 0; } if (len == 1) { return nums[0]; } // dp[i][0]：区间 [0, i] 里接受预约.
2021-03-08 13:55:14
40
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人