精华内容
下载资源
问答
  • 设置一个命中变量,初始化为0,记录两个数组连续连续命中的字节数量,命中数量等于字节数组B的长度时,返回true,如果循环到最后一个字节或者剩余字节长度小于字节数组B的长度时,命中变量都不等于字节数组B的长度,...

    目标

    实现一个字节数组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;
    	}
    
    展开全文
  • * 一次读取一个字节数组 * int read(byte[] b) * 返回值其实 实际读取的字节个数 * */ public class 一次读取一个字节数组 { public static void main(String[] args) throws IOException { // 创建字节...
    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();
    	}
    }
    
    展开全文
  • labview 读取的数组(整数)转换成16进制的字符串,方便大家进行数据处理。有问题可以留言咨询,互相学习
  • 一次读一个字节数组的方法 public int read(byte[] b):从输入流读取最多b.length个字节的数据 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数 示例代码 public class ...
    • 一次读一个字节数组的方法

      • 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判断一个字节数组在另一个字节数组的位置 有时候需要判断,一个字节数组在另一个字节数组的位置,其实只要判断第一位相等,然后后面多位持续比较,就可以判断是否有完全相同的片段。 由于项目需要,自己写了几...

    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的功能简单使用,当然如果有相应的功能需求,可以做相应的改变。

    共勉:很多人输就输在,对于新兴事物第一看不见,第二看不起,第三看不懂,第四来不及。

    展开全文
  • 自制 计算hex数组字节数,将字节序列按照字节在中间添加空格,并且计算字节序列的长度(10进制+16进制)
  • //因为读取一个字节数组, 所以定义一个 //数组变量 单位都可以,但最好是1024的倍数 int len ; //循环 while ((len = is.read(bytes))!=-1 ){ // 拷贝 os.write(bytes,0,len); } //释放 os.close(); is.close(); }...
  • 先查看一下jvm启动的默认参数,里面有2参数值对本次实验会造成影响。 命令行: java -XX:+PrintCommandLineFlags -version 查看jvm默认参数 分别是 -XX:+UseCompressedOops 和 -XX:+UseCompressedClassPointers 这...
  • 主要介绍了C#将字节数组转换成数字的方法,涉及C#类型转换的技巧,非常具有实用价值,需要的朋友可以参考下
  • 主要介绍了Java 将文件转为字节数组实例详解的相关资料,需要的朋友可以参考下
  • 字节数组添加空格

    2018-04-09 16:31:08
    字节数组添加空格,把数组自动添加空格,方便查看内容。
  • NULL 博文链接:https://zixiaolan.iteye.com/blog/452192
  • String.getBytes()是将字符串转化为一个字节数组。而String.toCharArray()是将一个字符串转化为一个字符数组。 【例如】 byte bys[] =“国庆60周年”.getBytes(); char chs[]=“国庆60周年”.toCharArray(); 【那么...
  • 易语言字节集与字节数组快速互转源码,字节集与字节数组快速互转,字节集到字节数组,字节数组字节集,字节集到字节数组_,复制内存_字节
  • 主要给大家介绍了关于Golang中字符串与字节数组的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用Golang具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 一、问题描述 如果直接用print打印bytes的话,有时候会直接显示ascii对应的...以上这篇对python以16进制打印字节数组的方法详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。
  • 主要介绍了C#将数字转换成字节数组的方法,涉及C#字符串操作的技巧,非常具有实用价值,需要的朋友可以参考下
  • 数组中的字节

    千次阅读 2020-06-17 16:26:15
    ##sizeof查看定义的数组所占用字节数 #include<iostream> int main(){ using namespace std; int Inter [10]; short sh [10]; char ch [10]; long lg [10]; float fl [10]; double dou [10]; cout...
  • 但是为了使后台接收上传文件的方法既使用网页上传,又适应桌面应用程序上传,方法的参数设置成两个,一个为字符串类型,接收文件名,另一个字节数组类型,用于接收文件内容。对于桌面应用,把文件内容读取到字节...
  • Java数组对象占用多少个字节?

    千次阅读 2020-12-15 17:40:27
    Java内存模型基础知识 对象内存中可以分为三块区域: 对象头(Header) ...众所周知Object object = new Object()占用了16字节,然后看一下下面几个数组占用空间大小 int[] intArr = new IntArr[3]; St...
  • 1、截取字节数组的前 num 个字节: /** * 截取字节数组的前 num 个字节 * * @param data * @param num * @return */ public static byte[] subBytes_Q(byte[] data, int num) { byte[] newByte = new byte[num...
  • 前台使用二进制字节数组将图片数据传递给对象的 byte[] 属性,后台向前台传送图片数据时,用的是基64字符串。如果前台向后台传送的不是基64字节数组,那么前台接收后台的图片数据时,就不能还原成图片了,需要做...
  • 字节数组中指定的位置读取一个Integer类型的数据 5.转换一个shor字符串为byte数组 6.从字节数组中指定的位置读取一个Short类型的数据 需要的朋友可以参考下,方便大家学习php
  • 数组在内存中所占字节数可以使用sizeof操作符来计算,该操作符是专门用于检测类型或变量或数组在内存中所占有的空间(字节数);语法“sizeof(x)”,其中x是类型名、变量名或数组名等,...
  • 、IO流 A:什么是IO流: IO流用于处理设备之间的数据传输 JAVA对于数据的操作都是通过流的操作 数据流操作都是在 IO包中 B:类型: 按照流操作分类: 输入流 输出流 按照流操作的数据类型分类: 字节流:...
  • 主要介绍了C#将布尔类型转换成字节数组的方法,涉及C#中字符串函数的使用技巧,非常具有实用价值,需要的朋友可以参考下
  • java 字符串 字节数组Today we will learn how to convert String to byte array in java. We will also learn how to convert byte array to String in Java. 今天,我们将学习如何在Java中将String转换为字节数组...
  • //从输入流中获取数据并以字节数组返回public class StreamTool { /** * 从输入流获取数据 * @param inputStream * @return * @throws Exception */ public static byte[] readInputStream(InputStream ...
  • 易语言字节数组演示源码,字节数组演示,字节集插入,字节集排序,字节集到字节数组_
  • 本工具可将大量C语言数组字节合并为一个字,如0x12,0x34,经过本工具合并后输出0x1234,需要注意的是输入格式需以“0x12,0x34,”一个字节后需要一个逗号。否则可能转换失败。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 676,283
精华内容 270,513
关键字:

如何确定一个数组的字节