目标
 
实现一个字节数组A包含另一个字节数组B的算法，顺序一致
 
原理
 
设置一个命中变量，初始化为0，记录两个数组连续连续命中的字节数量，命中数量等于字节数组B的长度时，返回true，如果循环到最后一个字节或者剩余字节长度小于字节数组B的长度时，命中变量都不等于字节数组B的长度，则返回false
 
算法
 
1.如果字节数组B长度大于字节数组A的长度，直接返回false
2.循环获取字节数组的每个字节值
3.命中变量等于字节数组B的长度，返回true
4.当前字节值是否等于索引为命中变量值的字节数组B中的字节值，如果是，命中变量自增1，continue到第2步继续下一个字节值的对比，否则继续第5步
5.命中变量置0
6.判断字节数组A的剩余字节数长度是否大于字节数组B的长度，如果大于则跳转到第2步执行循环体，否则跳出，返回false
 
实践
 
/**
	 * 判断是否一个字节数组按顺序包含另一个字节数组
	 * 
	 * @param pSrcByteArray
	 * @param pSubByteArray
	 * @return
	 */
	public static boolean isIncludeByteArray(byte[] pSrcByteArray, byte[] pSubByteArray) {
		boolean retValue = false;
		int lvSrcByteArrayLen = pSrcByteArray.length;
		int lvSubByteArrayLen = pSubByteArray.length;
		
		while(true) {
			if(lvSrcByteArrayLen < lvSubByteArrayLen) {
				break;
			}
			int lvHitByteNumberValue = 0;
			for(int i=0; i<lvSrcByteArrayLen; i++) {
				int tvByteValue = pSrcByteArray[i];
				if(lvHitByteNumberValue == pSubByteArray.length) {
					retValue = true;
					break;
				}
				if(tvByteValue == pSubByteArray[lvHitByteNumberValue]) {
					lvHitByteNumberValue++;
					continue;
				}
				lvHitByteNumberValue = 0;
				//剩余字节数
				int tvRemaindingByteLen = lvSrcByteArrayLen - i - 1;
				if(tvRemaindingByteLen < pSubByteArray.length) {
					break;
				}
			}
			break;
		}
		return retValue;
	}

package cn.itcast_02;

import java.io.FileInputStream;
import java.io.IOException;

/*
 * 
 * 一次读取一个字节数组
 * int read(byte[] b)
 * 返回值其实 实际读取的字节个数
 * 
 */
public class 一次读取一个字节数组 {

	public static void main(String[] args) throws IOException {
		// 创建字节输入流对象
		FileInputStream fis = new FileInputStream("fis.txt");
		
//		//读取数据
//		//定义一个字节数组
//		//第一次读取
//		byte[] bys = new byte[5];
//		int len = fis.read(bys);
//		//System.out.println(len);
//		//System.out.println(new String(bys));
//		System.out.print(new String(bys , 0 , len));
//		
//		//第二次读取
//		len = fis.read(bys);
//		//System.out.println(len);
//		//System.out.println(new String(bys));
//		System.out.print(new String(bys , 0 , len));
//		
//		//第三次读取
//		len = fis.read(bys);
//		//System.out.println(len);
//		//System.out.println(new String(bys));
//		System.out.print(new String(bys , 0 , len));
//		
//		//第四次读取
//		len = fis.read(bys);
//		//System.out.println(len);
//		//System.out.println(new String(bys));
//		System.out.print(new String(bys , 0 , len));
//		//如果读取到的实际长度是-1，就说明没有数据了
//		
		//用循环改进
//		byte[] by = new byte[115];//字节数组默认值是0
//		int len = 0;
//		while((len=fis.read(by)) != -1) {
//			System.out.print(new String(by ,0,len));
//			//System.out.print(new String(by));
//		}
		
		//最终代码
		//数组的长度一般是1024或者是1024的整数倍
		//因为1024字节的数据=1K
		byte[] by = new byte[1024];
		int len = 0;
		while((len = fis.read(by)) != -1) {
		System.out.print(new String(by , 0 , len));
		}
		//释放资源
		fis.close();
	}
}

 
一次读一个字节数组的方法
 
  
 
public int read(byte[] b)：从输入流读取最多b.length个字节的数据
 
 
返回的是读入缓冲区的总字节数,也就是实际的读取字节个数
 
 
示例代码
 
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次：ld\r\nr

         */

        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        fis.close();
    }
}
 
 

java判断一个字节数组在另一个字节数组的位置
 
有时候需要判断，一个字节数组在另一个字节数组的位置，其实只要判断第一位相等，然后后面多位持续比较，就可以判断是否有完全相同的片段。
 
由于项目需要，自己写了几个byte数组和String类的工具方法，给大家参考使用。
 
//判断一个字符串source中，有几个字符串src
getStringCount(String source, String src)

//判断一个字符串source中，从指定的位置开始开始计算，字符串src的游标值
getStringIndex(String source, String src, int beginIndex)

//判断一个byte数组src在另外一个byte数组sources中对应的游标值
getByteIndexOf(byte[] sources, byte[] src, int startIndex)

//判断一个byte数值src在另外一个byte数组sources中对应的游标值，指定开始的游标和结束的游标位置
getByteIndexOf(byte[] sources, byte[] src, int startIndex, int endIndex)

//判断一个byte数组src，在另一个byte数组source中存在的个数
getByteCountOf(byte[] sources, byte[] src)
 
简单的示例调用代码：
 

package com.example.lib2;


public class String20180903 {
    public static void main(String[] args) {
        //判断一个字符串中是否包含另个字符串
        String msg = "-aa-ab-aaa";
        String src = "aa";
        int count = getStringCount(msg, src); //返回的数量为：3
        System.out.println("count:" + count);

        int index = getStringIndex(msg, src, 2);
        System.out.println("index:" + index);   //返回的游标值为：7


        byte[] bytes = {73, 32, 87, 97, 110, 32, 89, 111, 117, 32, 87, 97, 110, 32, 77, 101};//"I Wan You Wan Me"
        byte[] bytes1={ 87, 97, 110};     //Wan
        int count2=getByteCountOf(bytes,bytes1);
        System.out.println("count2:" + count2); //返回的数量为：2

        int index2=getByteIndexOf(bytes,bytes1,0);
        System.out.println("index2:" + index2);   //返回的游标值为：2
    }

    //判断一个字符串source中，有几个字符串src
    private static int getStringCount(String source, String src) {
        int index = 0;
        int count = 0;
        int start = 0;
        while ((index = source.indexOf(src, start)) != -1) {
            count++;
            start = index + 1;
        }
        return count;
    }

    //判断一个字符串source中，从指定的位置开始开始计算，字符串src的游标值
    private static int getStringIndex(String source, String src, int beginIndex) {
        int index = 0;
        int start = 0;
        while ((index = source.indexOf(src, start)) != -1 && index < beginIndex) {
            start = index + 1;
        }
        return index;
    }

    //判断一个byte数值在另外一个byte数组中对应的游标值
    public static int getByteIndexOf(byte[] sources, byte[] src, int startIndex) {
        return getByteIndexOf(sources, src, startIndex, sources.length);
    }


    //判断一个byte数值在另外一个byte数组中对应的游标值，指定开始的游标和结束的游标位置
    public static int getByteIndexOf(byte[] sources, byte[] src, int startIndex, int endIndex) {

        if (sources == null || src == null || sources.length == 0 || src.length == 0) {
            return -1;
        }

        if (endIndex > sources.length) {
            endIndex = sources.length;
        }

        int i, j;
        for (i = startIndex; i < endIndex; i++) {
            if (sources[i] == src[0] && i + src.length < endIndex) {
                for (j = 1; j < src.length; j++) {
                    if (sources[i + j] != src[j]) {
                        break;
                    }
                }

                if (j == src.length) {
                    return i;
                }
            }
        }
        return -1;
    }


    //判断一个byte数组src，在另一个byte数组source中存在的个数
    public static int getByteCountOf(byte[] sources, byte[] src) {
        if (sources == null || src == null || sources.length == 0 || src.length == 0) {
            return 0;
        }
        int count = 0;
        int start = 0;
        int index = 0;
        while ((index = getByteIndexOf(sources, src, start)) != -1) {
            start = index + 1;
            count++;
        }
        return count;
    }


}

 
上面就是一些Byte数组和String的功能简单使用，当然如果有相应的功能需求，可以做相应的改变。
 
共勉：很多人输就输在，对于新兴事物第一看不见，第二看不起，第三看不懂，第四来不及。