public void mkdirHDFS() throws URISyntaxException, IOException, InterruptedException {
        //1、创建配置对象
        Configuration conf = new Configuration();
        //2、获取文件系统
        FileSystem fs = FileSystem.get(new URI("hdfs://vmaster:9000"), conf, "root");
        //3、创建目录
        fs.mkdirs(new Path("hdfs://vmaster:9000/Good"));
        //4、关闭文件系统
        fs.close();
    }

public void delHDFS() throws URISyntaxException, IOException, InterruptedException {
    //1、创建配置对象
    Configuration conf = new Configuration();
    //2、获取文件系统
    FileSystem fs = FileSystem.get(new URI("hdfs://vmaster:9000"), conf, "root");
    //3、删除文件
    //Path var1,删除的路径
    // boolean var2//是否递归删除
    fs.delete(new Path("hdfs://vmaster:9000/Good"),true);
    //4、关闭系统
    fs.close();
    System.out.println("del");
}

public void  getFileFromHDFS() throws URISyntaxException, IOException, InterruptedException {
    //1、创建配置信息对象
    Configuration conf = new Configuration();

    //2、找到文件系统
    FileSystem fs = FileSystem.get(new URI("hdfs://vmaster:9000"),conf,"root");

    //3、下载文件
    //boolean delSrc,是否将源文件删除
    // Path src,要下载的路径
    // Path dst, 要下载到那
    // boolean useRawLocalFileSystem：是否校验文件
    //
    fs.copyToLocalFile(false,new Path("hdfs://vmaster:9000/transaction_details.csv"),new Path("F:\\Course\\BigData"),true);

    //4、关闭文件系统
    fs.close();
    System.out.println("OKl");
}

public void readLsitFile() throws URISyntaxException, IOException, InterruptedException {
        //1、创建配置对象
        Configuration conf = new Configuration();
        //2、获取文件系统
        FileSystem fs = FileSystem.get(new URI("hdfs://vmaster:9000"), conf, "root");
        //3、迭代器
        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("hdfs://vmaster:9000/"), true);
        //4、遍历迭代器
        while(listFiles.hasNext()){
            LocatedFileStatus fileStatus = listFiles.next();

            //路径名
            System.out.println("文件名" + fileStatus.getPath().getName());
            //块的大小
            System.out.println("大小" + fileStatus.getBlockSize());
            //权限
            System.out.println("权限" + fileStatus.getPermission());
            //
            System.out.println(fileStatus.getLen());

            BlockLocation[] locations = fileStatus.getBlockLocations();
            for(BlockLocation bl:locations){
                System.out.println("block-offset" + bl.getOffset());
                String[] hosts = bl.getHosts();
                for(String host:hosts){
                    System.out.println(host);
                }
            }
            System.out.println("----------------------------------------");
        }
    }

public void checkFile() throws URISyntaxException, IOException, InterruptedException {
    //1、创建配置对象
    Configuration conf = new Configuration();
    //2、获取文件系统
    FileSystem fs = FileSystem.get(new URI("hdfs://nna:9000"), conf, "root");
    //3、遍历所有文件
    FileStatus[] status = fs.listStatus(new Path("/"));
    for(FileStatus status1:status){
        //判断是否为文件
        if(status1.isFile()){
            System.out.println("文件：" + status1.getPath().getName());
        }else {
            System.out.println("目录：" + status1.getPath().getName());
        }
    }

    //4、关闭文件系统
    fs.close();
}

class Singleton {
private Singleton() {
}

private  static Singleton instance;
static { 
instance = new Singleton();
}
public static Singleton getInstance() {
return instance;
}
}

class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
    instance = new Singleton();
}
}
return instance;
}
}

class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

class Singleton {
private static Singleton instance;
private Singleton() {}
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton(); 
}
public static Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}

enum Singleton {
public void sayHello() {
System.out.println("Hello");
}
}

public class SingleResposibility01 {
public static void main(String[] args) {
Fruit fruit = new Fruit();
fruit.eat("苹果");
fruit.eat("葡萄");
fruit.eat("菠萝");
}
}

class Fruit{
public void eat(String fruit) {
System.out.println("正在红色的" + fruit);
}
}

public class SingleResponsibility02 {
public static void main(String[] args) {

RedFriut redFriut = new RedFriut();
redFriut.eat("苹果");
GreenFruit greenFruit = new GreenFruit();
greenFruit.eat("葡萄");
YellowFruit yellowFruit = new YellowFruit();
yellowFruit.eat("菠萝");
}
}
class RedFriut{
public void eat(String fruit) {
System.out.println("正在红色的" + fruit);
}
}
class GreenFruit{
public void eat(String fruit) {
System.out.println("正在绿色的" + fruit);
}
}
class YellowFruit{
public void eat(String fruit) {
System.out.println("正在黄色的" + fruit);
}
}

public class SingleResposibility03 {
public static void main(String[] args) {
MyFruit fruit = new MyFruit();
fruit.eatRedFruit("苹果");
fruit.eatGreenFruit("葡萄");
fruit.eatYellowFruit("菠萝");
}
}

class MyFruit {
public void eatRedFruit(String Fruit) {
System.out.println("正在吃红色的" + Fruit);
}
public void eatGreenFruit(String Fruit) {
System.out.println("正在吃绿色的" + Fruit);
}
public void eatYellowFruit(String Fruit) {
System.out.println("正在吃黄色的" + Fruit);
}
}

interface interface1{
public void method1();
public void method2();
public void method3();
public void method4();
public void method5();
}
class C implements interface1{

@Override
public void method1() {
System.out.println("C 实现了接口1的方法1");

}

@Override
public void method2() {
System.out.println("C 实现了接口1的方法2");
}

@Override
public void method3() {
System.out.println("C 实现了接口1的方法3");
}

@Override
public void method4() {
System.out.println("C 实现了接口1的方法4");
}

@Override
public void method5() {
System.out.println("C 实现了接口1的方法5");
}
}
class D implements interface1{

@Override
public void method1() {
System.out.println("D 实现了接口1的方法1");

}

@Override
public void method2() {
System.out.println("D 实现了接口1的方法2");
}

@Override
public void method3() {
System.out.println("D 实现了接口1的方法3");
}

@Override
public void method4() {
System.out.println("D 实现了接口1的方法4");
}

@Override
public void method5() {
System.out.println("D 实现了接口1的方法5");
}
}
class A{
public void depend1(interface1 i) {
i.method1();
}
public void depend2(interface1 i) {
i.method2();
}
public void depend3(interface1 i) {
i.method3();
}
}
class B{
public void depend1(interface1 i) {
i.method1();
}
public void depend4(interface1 i) {
i.method4();
}
public void depend5(interface1 i) {
i.method5();
}
}

public class DInversion {
Food food;
public static void main(String[] args) {
//1. 接口传递
Fruit fruit = new Fruit();
Operation operation = new Operation();
operation.operate(fruit);

//2. 构造方法传递
Operation operation2 = new Operation(new Vegetable());
operation2.operate();

//3. setter方法传递
Operation operation3 = new Operation();
operation3.setFood(fruit);
operation3.operate();
}

}

class Operation{
private Food food;

public Operation() {
}
public Operation(Food food) {
this.food = food;
}

public void setFood(Food food) {
this.food = food;
}

public void operate(Food food) {
food.eat();
}

public void operate() {
food.eat();
}
}

interface Food{
public void eat();
}

class Vegetable implements Food{

@Override
public void eat() {
System.out.println("吃蔬菜...");
}

}

class Fruit implements Food{

@Override
public void eat() {
System.out.println("吃水果..");
}

}

public class Test {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawCircle(new Circle());
graphicEditor.drawRectangle(new Rectangle());

}
}

class GraphicEditor {
public void drawShape(Shape s) {
if (s.m_type == 1)
drawRectangle(s);
else if (s.m_type == 2)
drawCircle(s);
}

public void drawRectangle(Shape r) {
System.out.println("矩形");
}

public void drawCircle(Shape r) {
System.out.println("圆形");
}
}


class Shape {
int m_type;
}

class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
}

class Circle extends Shape {
Circle() {
super.m_type = 2;
}
}

public class OCP {
public static void main(String[] args) {
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());

//增加图形而不更改调用的方法，（使用方）
//正在运行的方法位置（提供方）
graphicEditor.drawShape(new Triangle());
}

}
/**
 * 使用方
 */
class GraphicEditor {
public void drawShape(Shape s) {
s.draw();
}
}


abstract class Shape {
int m_type;
public abstract void draw();
}

class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}

@Override
public void draw() {
System.out.println("画矩形");
}

}

class Circle extends Shape {
Circle() {
super.m_type = 2;
}

@Override
public void draw() {
System.out.println("画圆");
}

}
class Triangle extends Shape{

public Triangle() {
super.m_type = 3;
}
@Override
public void draw() {
System.out.println("画三角形");
}

}

public class Demeter {
public static void main(String[] args) {
new PoisonousAirMaking().make(new GeneralAirMaking());
}
}

class GeneralAirMaking{
private ArrayList<GeneralAir> list = new ArrayList<>();

public ArrayList<GeneralAir> retrieve() {
list.add(new GeneralAir("氧气"));
list.add(new GeneralAir("二氧化碳"));
list.add(new GeneralAir("氮气"));
return list;
}
}
class PoisonousAirMaking{
private ArrayList<PoisonousAir> list = new ArrayList<>();

public ArrayList<PoisonousAir> retrieve() {
list.add(new PoisonousAir("一氧化碳"));
list.add(new PoisonousAir("氨气"));
list.add(new PoisonousAir("二氧化硫"));
return list;
}

public void make(GeneralAirMaking sub) {
retrieve();
for(PoisonousAir paAir:list) {
System.out.println("有毒气体--"+paAir.getType());
}
System.out.println("---");
ArrayList<GeneralAir> list2 = sub.retrieve();
for(GeneralAir gAir: list2) {
System.out.println("普通气体--" + gAir.getType());
}

}
}
class GeneralAir{
private String type;

public GeneralAir(String type) {
super();
this.type = type;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}
}

class PoisonousAir{
private String type;

public PoisonousAir(String type) {
super();
this.type = type;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}
}

public class Demeter {
public static void main(String[] args) {
new PoisonousAirMaking().make(new GeneralAirMaking());
}
}

class GeneralAirMaking{
private ArrayList<GeneralAir> list = new ArrayList<>();

public ArrayList<GeneralAir> retrieve() {
list.add(new GeneralAir("氧气"));
list.add(new GeneralAir("二氧化碳"));
list.add(new GeneralAir("氮气"));
return list;
}
public void make() {
retrieve();
for(GeneralAir gAir: list) {
System.out.println("普通气体--" + gAir.getType());
}
}
}
class PoisonousAirMaking{
private ArrayList<PoisonousAir> list = new ArrayList<>();

public ArrayList<PoisonousAir> retrieve() {
list.add(new PoisonousAir("一氧化碳"));
list.add(new PoisonousAir("氨气"));
list.add(new PoisonousAir("二氧化硫"));
return list;
}

public void make(GeneralAirMaking sub) {
retrieve();
for(PoisonousAir paAir:list) {
System.out.println("有毒气体--"+paAir.getType());
}
System.out.println("---");
sub.make();


}
}
class GeneralAir{
private String type;

public GeneralAir(String type) {
super();
this.type = type;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}
}

class PoisonousAir{
private String type;

public PoisonousAir(String type) {
super();
this.type = type;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}
}

  public int[][] merge(int[][] a) {
  //1. 先去除a为空的情况
  if(a.length==0)return new int[][]{};
  Integer[][] intervals = new Integer[a.length][a[0].length];
  //2. 为了方便排序，将其转换为Integer数组
  cpy(a, intervals);
  
  //3. 排序
  Arrays.sort(intervals, new Comparator<Integer[]>() {

   @Override
              public int compare(Integer[] x, Integer[] y) {
                  if(x[0] < y[0]){
                      return -1;
                  } else if(x[0] > y[0]){
                      return 1;
                  } else {
                      return 0;
                  }
              }

});
//4. 遍历查找是否相交
  ArrayList<Integer[]> list = new ArrayList<>();
  for(int i=0;i<intervals.length;i++) {
  int j = i;
  Integer[] tIntegers = new Integer[2];
  tIntegers[0] = intervals[i][0];
  tIntegers[1] = intervals[i][1];
  //有相交的情况
  while(i+1<=intervals.length-1&&intervals[i+1][0]<=tIntegers[1]) {
  if(intervals[i+1][1]>tIntegers[1]) {
  tIntegers[1] = intervals[i+1][1];
  }
  i++;
  }
  
  list.add(tIntegers);
  }
  //5. 转换为int[][]返回
  int[][] res = new int[list.size()][2];
  for(int i=0;i<list.size();i++) {
  Integer[] integers = list.get(i);
  res[i][0] = integers[0];
  res[i][1] = integers[1];
  }
return res;
  }

class Solution {
    public boolean canJump(int[] nums) {
        return jump(nums, 0);
    }
private boolean jump(int[] nums, int current) {

if(current+nums[current]>=nums.length-1) {
return true;
}
if(nums[current]==0)return false;
//找最大
int maxi = current+1;
while(maxi+nums[maxi]<current+nums[current])maxi++;

if(maxi<current+nums[current]) {
return jump(nums, maxi);
}else {
return jump(nums, current+nums[current]);
}
}

}

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
    ArrayList<Integer> list = new ArrayList<>();
    
    int i=0,j=0;
    int n=matrix.length;
        if(n==0)return list;
    int m = matrix[0].length;
    int cnt = 0,loop=0;
    while(cnt<m*n) {
    while(cnt<n*m&&j<m-loop) {
    list.add(matrix[i][j]);
    cnt++;
    j++;
    }
    
    j--;
    i++;
    
    while(cnt<m*n&&i<n-loop) {
    list.add(matrix[i][j]);
    
    i++;
    cnt++;
    }
    
    i--;
    j--;
    
    while(cnt<m*n&&j>=loop) {
    list.add(matrix[i][j]);
    cnt++;
    j--;
    }
    j++;
    i--;
    
    while(cnt<m*n&&i>loop) {
    list.add(matrix[i][j]);
    i--;
    cnt++;
    }
    i++;
    j++;
    loop++;
    //System.out.println(list);
    }
    
return list;
        
    }
}

  public List<Integer> spiralOrder(int[][] matrix) {
  ArrayList<Integer> list = new ArrayList<>();
  
  int i=0,j=0;
  int m=matrix.length;
      if(m==0)return list;
  int n = matrix[0].length;
  int cnt = 0,loop=0;
  while(cnt<m*n) {
  i=loop;
  j=loop;
  for(int k=j; k<n-loop;k++,cnt++) {
  list.add(matrix[i][k]);
  }
  j += n-loop-1;
  
  for(int k=i+1;k<m-loop;k++,cnt++) {
  list.add(matrix[k][j]);
  }
  i += m-loop-1;
  for(int k=j-1; k>=loop;k--,cnt++) {
  list.add(matrix[i][k]);
  }
  j = loop;
  for(int k=i-1;k>loop;k--,cnt++) {
  list.add(matrix[k][j]);
  }
  
  loop++;
  //System.out.println(list);
  }
  
return list;
      
  }

  public List<Integer> spiralOrder(int[][] matrix) {
  ArrayList<Integer> list = new ArrayList<>();
  
  int i=0,j=0;
  int m=matrix.length;
      if(m==0)return list;
  int n = matrix[0].length;
  
  int[][] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
  int idx = 0;
  for(int k=0;k<m*n;k++) {
  
  list.add(matrix[i][j]);
  matrix[i][j] = 1000;
  int x = i + dirs[idx][0];
  int y = j + dirs[idx][1];
  if(x<0 || y<0 || x>=m || y>=n || (matrix[x][y]^1000)==0) {
  idx = (idx + 1)%4;
  x = i + dirs[idx][0];
  y = j + dirs[idx][1];
  }
  i=x;
  j=y;
  }
  
return list;
      
  }

class Solution {
boolean[][] visited;
private List<List<String>> res = new ArrayList<List<String>>();
    public List<List<String>> solveNQueens(int n) {

        List<StringBuffer> list = new ArrayList<StringBuffer>();
        visited = new boolean[3][n*2];
        for(int i=0; i<n;i++) {
            StringBuffer sbuf = new StringBuffer();
            for(int j=0;j<n;j++){
                sbuf.append('.');
            }
        list.add(sbuf);
        }
        search(list, 0, n);
        
        return res;
    }
    
public void search(List<StringBuffer> list, int cur, int n) {
if(cur==n) {
ArrayList<String> list2 = new ArrayList<>();
for(StringBuffer sb: list) {
list2.add(sb.toString());
}
res.add(list2);
return ;
}else {
for(int i=0;i<n;i++) {
//System.out.println(cur-i+n+";;"+visited[0].length);
if(!visited[0][i]&&!visited[1][cur+i]
&&!visited[2][cur-i+n]) {
list.get(cur).setCharAt(i, 'Q');
visited[0][i] = visited[1][cur+i] = visited[2][cur-i+n]=true;
search(list, cur+1, n);

list.get(cur).setCharAt(i, '.');
visited[0][i] = visited[1][cur+i] = visited[2][cur-i+n] = false;
}
}
}


}

}

public class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
    List<List<String>> list = new ArrayList<List<String>>();
    Map<String, Integer> map = new HashMap<>();
    for(int i=0;i<strs.length;i++) {
    
    
    String current = sortString(strs[i]);
    Integer index;
    if((index = map.get(current))==null) {
    ArrayList<String> list2 = new ArrayList<>();
    map.put(current, list.size());
    list2.add(strs[i]);
    list.add(list2);
    
    }else {
    //System.out.println(strs[i]+",index="+index);
    List<String> list2 = list.get(index);
    list2.add(strs[i]);
    }
    }
return list;
    }
    
    public String sortString(String str) {
    char[] cs = str.toCharArray();
Arrays.sort(cs);

return Arrays.toString(cs);
    }

    
public static void main(String[] args) {
String[] input = {"eat","tea", "tan", "ate", "nat", "bat"};
System.out.println(new Solution().groupAnagrams(input));
}
}

public void rotate(int[][] matrix) {
    int[][] tmp = new int[matrix.length][matrix.length];
for(int i=0;i<matrix.length;i++) {
for(int j=0;j<matrix.length;j++) {
tmp[i][j] = matrix[i][j];
}
}
for(int i=0;i<matrix.length;i++) {
for(int j=0;j<matrix.length;j++) {
matrix[j][matrix.length-i-1] = tmp[i][j];
}

}
}

public class Solution {
private List<List<Integer>> list = new ArrayList<List<Integer>>();
    public List<List<Integer>> permuteUnique(int[] nums) {
    Arrays.sort(nums);
    
    permute(nums,new int[nums.length], 0);
    
return list;
}
    
private void permute(int[] nums,int[] A, int cur) {
if(cur==nums.length) {
//System.out.println("nums[cur]="+nums[cur]);
list.add(toList(A));
}else {
for(int i=0;i<nums.length;i++) {
if(i==0||nums[i]!=nums[i-1]) {
int c1 = 0;
int c2 = 0;
for(int j = 0; j<cur;j++) {
System.out.println("cur="+cur+","+A[j]);
if(nums[i]==A[j])c1++;
}
for(int j=0;j<nums.length;j++) {
if(nums[i]==nums[j])c2++;
}
if(c1<c2) {
A[cur] = nums[i];
permute(nums, A, cur+1);
//tmp.remove(i);
}
}
}
}

}

    public List toList(int[] nums) {
    ArrayList<Object> arrayList = new ArrayList<>();
    for(Integer e: nums) {
    arrayList.add(e);
    }
    return arrayList;
    }
public static void main(String[] args) {
int[] nums = {1,1,2};

System.out.println(new Solution().permuteUnique(nums).toString());
}
}

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> list = new ArrayList<List<Integer>>();
    int rht = nums.length - 1;
    int j = rht;
    
    list.add(toList(nums));
    
    while(j >= 0) {
    
    j = rht;
    while(j-1 >=0 && nums[j] < nums[j-1])j--;
    if(j-1 < 0) return list;
    
    int i = j;
    while(i<=rht && nums[i] > nums[j-1]) i++;
    if(i>rht)i=rht+1;
    swap(nums, i-1, j-1);
    
    //Arrays.sort(nums, j, rht+1);
    
    reverse(nums, j, rht);
    list.add(toList(nums));
    
    
    }
    
    
return null;
}
    public void reverse(int[] nums, int i, int j) {
    int mid = (i+j)/2;
    if(mid==nums.length-1)return;
    if((i+j)%2==1) {
    for(int a = mid; a>=i;a--) {
    swap(nums, a, 2*mid-a+1);
    }
    }else {
    for(int a = mid-1; a>=i;a--) {
    swap(nums, a, 2*mid-a);
    }
    }
    }
    public List toList(int[] nums) {
    ArrayList<Object> arrayList = new ArrayList<>();
    for(Integer e: nums) {
    arrayList.add(e);
    }
    return arrayList;
    }
    public void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
    }
public static void main(String[] args) {
int[] nums = {2,6,1};

System.out.println(new Solution().permute(nums).toString());
}
}