【java】IO流，【华为面试】找出最长字符串（包括第一二一样长同时输出）

 

 

FileInputStream字节流只能读ASCII码文件，文件中有中文字符都不能用他读

 

序列化和反序列化 

对象从内存写入磁盘的过程称为对象的持久化，也称为序列化

从磁盘中读取文件到内存还原为对象的过程称为反序列化

IO流有几种，流怎么分类

1.流按照方向分

输入

输出

2.流按照传输单位 

字节

字符

3.java提供了四个基类

4.字节流常用的有  文件  对象  二进制

5.字符流中常用的有    文件   一次读一行的缓冲流 

【华为面试】找出最长字符串（包括第一二一样长同时输出）

解法一：暴力枚举

package findLongString;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Demo02 {
    public static void main(String[] args) {
        String s="abadac";
        fing(s);
    }
    public static void fing(String str){
        Set<String> set = new TreeSet<>();

        String result="";
        int max=0;
        HashMap<String,Integer> map=new HashMap<>();
        System.out.println("length:"+str.length());
        for (int i = 0; i < str.length(); i++) {
            for (int j = i+1; j <=str.length() ; j++) {
                set.add(str.substring(i,j));
            }
        }

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            TreeSet<String> set1 = new TreeSet<>();
            String next = iterator.next();
            for (int i = 0; i < next.length(); i++) {
                set1.add(String.valueOf(next.charAt(i)));
            }
            if (set1.size()==next.length()){
                int len=next.length();
                if (max<=len){
                    max=len;
                    result= next;
                    map.put(result,max);
                }
            }
        }
        int a=max;
        map.forEach((k,v)->{
            if (map.get(k)==a){
                System.out.println(k);
            }
        });
        System.out.println(max);
    }
}
 

解法二：滑动窗口

有回溯

package findLongString;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.*;

public class huaDong {
    public static void main(String[] args) {
        String a="abadac";
        getHuiSu(a);
    }
    public static void getHuiSu(String s){
        if (s==null||s.length()==0){
            System.out.println("kong");
        }
        int start=0;
        int maxlen=0;
        int len=0;
//        int startMaxIndex=0;
        Map<Character, Integer> map = new HashMap<>();
        Map<String, Integer> map1 = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char ch=s.charAt(i);
            Integer value=map.get(ch);

            if (map.containsKey(ch)){
                start=value+1;
                len=0;

                map=new HashMap<>();
                i=value;
            }else {
                map.put(ch,i);

                len++;
                if (len>=maxlen){

                    maxlen=len;
//                    startMaxIndex=start;
                    map1.put((s.substring(start, (start + len))),len);
//                    map1.put((s.substring(startMaxIndex, (startMaxIndex + maxlen))),maxlen);

                }
            }
        }
        int a=maxlen;
        map1.forEach((k,v)->{
            if (map1.get(k)==a){
                System.out.println(k);
            }
        });
    }
}
 

无回溯

等我学会了再说。。。。。。。