java,Code片段,代码实例,代码示例,代码片段库

java 删除多余的括号

对于某个字符串，其中仅仅包含（，）和字母，删除最少的多余括号来使其其匹配。 BFS：去掉每一个（或），看看剩下的字符串是否是匹配的，递归调用。涉及到DFS或BFS的都是暴力搜索。

bfs

public List<String> removeIntervalPathneses(String s){
  Set<String> visited = new HashSet<>();
  Queue<String> queue = new LinkedList<>();
  List<String> res= new ArrayList<>();
  queue.add(s);
  while(!queue.isEmpty()){
    String t = q.remove();
    if(isValid(t)){
        res.add(t);
        found=true;
    }
    if(found) continue;
    for(int i = 0 ; i < t.length(); i++){
        if(t.charAt(i)!='(' && t.charAt(i)!=')') continue;
        String str = t.subtring(0,i)+t.substring(i+1);
        if(!visited.contains(str)){
            visited.add(str);
            q.add(str);
        }
    }
  }
  return res;
}
public boolean isValid(String cur){
  int n = cur.length();
  int leftP = 0 ;
  int rightP = 0 ;
  for(int i = 0 ; i < n; i++){
    if(cur.charAt(i)!='(' && cur.charAt(i)!=')') cotinue;
    if(cur.charAt(i)=='(') leftP++;
    else if(cur.charAt(i)==')') rightP++;
    if(rightP>leftP) return false;
  }
  return leftP==rightP;
}

java 添加括号分拆运算--medium

若输入是数字和运算符的时候，比如“1 + 1”这种情况，那么加不加括号也没有任何影响，因为只有一个计算，结果一定是2.再复杂一点的话，比如题目中的例子1，输入是“2-1-1”时，就有两种情况了，（2-1）-1和2-（1-1），由于括号的不同，得到的结果也不同，但如果我们把括号里的东西当作一个黑箱的话，那么其就变为（）-1和2-（），其最终的结果跟括号内可能得到的值是息息相关的，那么再一般一点，实际上就可以变成（）？（）这种形式，两个括号内分别是各自的表达式，最终会分别计算得到两个整型数组，中间的问号表示运算符，可以是加，减，或乘。那么问题就变成了从两个数组中任意选两个数字进行运算，瞬间变成我们会做的题目了有木有？而这种左右两个括号代表的黑盒子就交给递归去计算，像这种分成左右两坨的模式就是大名鼎鼎的分治法Divide and Conquer了，是必须要掌握的一个神器。

Divide and Conquer

HashMap<String,List<Integer>> map = new HashMap<String,List<Integer>>();
public list<Integer> diffWaysToCompute(String input){
    if(map.get(input)!=null) return map.get(input);
    List<Integer> res = new ArrayList<Integer>();
    for(int i = 0; i < input.length(); i++){//这是高级分支，因为一般分治算法只有两个递归调用，然后或者在前或者在后来处理具体情况，而这里采用的是循环配递归调用，所以有点类似于全排列算法
        if(input.charAt(i)=='+' || input.charAt(i)=='*' || input.charAt(i)=='-'){
            List<Integer> left = diffWaysToCompute(input.substring(0,i));
            List<Integer> right = diffWaysToCompute(input.substring(i+1));
            for(int j = 0; j < left.size(); j++){
                for(int k = 0; k < right.size(); k++){
                    if(input.charAt(i)=='+') res.add(left.get(j)+right.get(k));
                    else if(input.charAt(i)=='-') res.add(left.get(j)-right.get(k));
                    else res.add(left.get(j)*right.get(k));
                }
            }
        }
    }
    if(res.isEmpty()) res.add(stoi(input));
    map.put(input ,res);
    return res;
}

java 有效的括号匹配问题

给定一个只包括'（'，'）'，'{'，'}'，'['，']'的字符串，判断字符串是否有效。 Stack栈

stack

public boolean isValid(String s){
  if(s==null || s.length()==0) return true;
  Stack<Character> stack = new Stack<>();
  for(int i = 0; i < s.length(); i++){
    if(s.charAt(i)=='{' || s.charAt(i)=='[' || s.charAt(i)=='(')
      stack.push(s.charAt(i));
    else{
      char c = stack.peek();
      if((s.charAt(i)=='}' && c=='{') || (s.charAt(i)==')' && c=='(') || (s.charAt(i)==']' && c=='['))
        stack.pop();
      else return false;
    }
  }
  return true;
}

java Palindrome Partition II--分割回文字符串二

给定一个字符串，分割成多个子字符串，使得每个子字符串都是回文字符串，求最少分割多少次。 一看就是动态规划，dp [i]表示原字符串0 〜我之间要分割成回归子串最少的分割次数，此种定义dp的方法导致类似于最长递增子序列的方法。更新dp [i]，前面说过了其其表示子串[0，i ]范围内的最小分割数。那么这个区间的每个位置都可以尝试分割开来，所以就用一个变量j来从0遍历到i，这样就可以把区间[0，i]分为两部分， [0，j-1]和[j，i]，那么假设已经知道区间[0，j-1]的最小分割数dp [j-1]，因为我们是从前往后更新的，而j小于等于我，所以dp [j-1]肯定在dp [i]之前就已经算出来了。这样我们就只需要判断区间[j，i]内的子串是否为回文串了，是的话，dp [ i]就可以用1 + dp [j-1]来更新了。判断子串的方法用的是之前那道Palindromic Substrings一样的方法，使用一二维的dp数组p，其中p [i] [j]表示区间[i，j]内的子串是否为回文串，其状态转移方程为p [i] [j] =（s [i] == s [j]）&& p [i + 1] [j-1]，其中p [i] [j] =真如果[i，j]为回文。这样的话，这道题实际相当于同时用了两个DP的方法。

public int minCutToPalindrome(String s){
  if(s==null || s.length()==0) return  0;
  int n = s.length();
  boolean [][] p = new boolean[n][n];
  int dp = new int[n];
  for(int i =0; i < n; i++){
    dp[i]=i;
    for(int j = 0;j <= i; j++){
      if(s.charAt(i)==s.charAt(j) && (i-j<=2 || dp[j+1][i-1])){
        p[j][i]=true;
        dp[i] = (j==0)?0:min(dp[i],dp[j-1]+1);
      }
    }
  }
  return dp[n-1];
}

java FileRemoveLine

https://stackoverflow.com/questions/1377279/find-a-line-in-a-file-and-remove-it

RemoveLine

File inputFile = new File("myFile.txt");
File tempFile = new File("myTempFile.txt");

BufferedReader reader = new BufferedReader(new FileReader(inputFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));

String lineToRemove = "bbb";
String currentLine;

while((currentLine = reader.readLine()) != null) {
    // trim newline when comparing with lineToRemove
    String trimmedLine = currentLine.trim();
    if(trimmedLine.equals(lineToRemove)) continue;
    writer.write(currentLine + System.getProperty("line.separator"));
}
writer.close(); 
reader.close(); 
boolean successful = tempFile.renameTo(inputFile);

java FIleReadLines

文件读取线

ReadLastLine

BufferedReader br = Files.newBufferedReader(Paths.get(filePath));
String output=br.lines().reduce((first,second)->second).orElse(null);

ReadAllLines

BufferedReader br = Files.newBufferedReader(Paths.get(filePath));
List<String>list=br.lines().collect(Collectors.toList());

java StreamLastElement

从列表中获取最后一个元素 https://www.baeldung.com/java-stream-last-element

Reduce


List<String> valueList = new ArrayList<>();
valueList.add("Joe");
valueList.add("John");
valueList.add("Sean");

Stream<String> stream = valueList.stream();
stream.reduce((first, second) -> second)
  .orElse(null);

Skip


List<String> valueList = new ArrayList<String>();
valueList.add("Joe");
valueList.add("John");
valueList.add("Sean");

long count = valueList.stream().count();
Stream<String> stream = valueList.stream();
    
stream.skip(count - 1).findFirst().get();

InfiniteStream


List<String> valueList = new ArrayList<String>();
valueList.add("Joe");
valueList.add("John");
valueList.add("Sean");


Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
stream.reduce((first, second) -> second).orElse(null);

java FileClear

FileClear

Files.newBufferedWriter(pathObject , StandardOpenOption.TRUNCATE_EXISTING);

java FileCheckIfempty

检查文件是否为空

EmptyCheck

BufferedReader br = new BufferedReader(new FileReader("path_to_some_file"));     
if (br.readLine() == null) {
    System.out.println("No errors, and file empty");
}

java 文件已存在

FileExists

File tempFile = new File("c:/temp/temp.txt");
boolean exists = tempFile.exists();