byte[1024] 这个有多大

Question

这没有什么大的关系，你就是用999这样的数字也没有问题，就是每次读取的最大字节数。
例如一个2049字节的文件，你如果把buf设置成1024字节，则需要读3次，第一、二次读取到1024个字节，第三次读取到1个字节，就这么简单，与实际程序运行效果没有影响，只不过是多读几次而已。不过网络编程的时候，大小设置就需要比较合理了，因为要考虑粘包的问题。

Answer 1

InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];      //分配1024个字节大小的内存给buf
        int len = in.read(buf);                              //等同于read(b, 0, b.length) ，即读取1024个字节放到buf中，
        String text = new String(buf, 0, len);    //将读取的1024个字节构造成一个String类型的变量

Answer 2

新号，回复的第一个帖子，哈哈！
1024Byte=1KB，分配1KB的缓存

Answer 3

InputStream in = s.getInputStream();

byte[] buf = new byte[1024];
int len = in.read(buf);
String text = new String(buf, 0, len);
你的这段代码是将输入流中的1024个字节放入buf缓存， 然后将buf缓存中的字节转化为字符串。
如果没有循环读流的话，那就只读了1024个字节，buf的大小对程序结果有影响，可能读不到所有输入流中的字节。
如果你有循环读流，那buf的大小其实对程序的结果是没有影响的，这种情况下，buf之相当于一个中间临时缓存。

Answer 4

就是说它自身就有循环，不需要自己再写一个循环，是这样的吗？
不是自身有循环，这样写只是定义一个字节数组作为一个缓存，临时存储输入流读取到的数据
如果你没加循环的话就只读1024Byte大小的数据。这样写应该是确定要读取的文件不超过1KB吧。
如果不确定读取的数据大小就要加循环了InputStream in = s.getInputStream();
         
byte[] buf = new byte[1024];
int len = -1;
while((len=in.read(buf))!=-1){
       //这里对读取到的数据进行处理
       // 比如这样
      String text = new String(buf, 0, len);
}

Answer 5

就是说它自身就有循环，不需要自己再写一个循环，是这样的吗？
不是自身有循环，这样写只是定义一个字节数组作为一个缓存，临时存储输入流读取到的数据
如果你没加循环的话就只读1024Byte大小的数据。这样写应该是确定要读取的文件不超过1KB吧。
如果不确定读取的数据大小就要加循环了InputStream in = s.getInputStream();
         
byte[] buf = new byte[1024];
int len = -1;
while((len=in.read(buf))!=-1){
       //这里对读取到的数据进行处理
       // 比如这样
      String text = new String(buf, 0, len);
}OK 明白了，谢了

Answer 6

就是说它自身就有循环，不需要自己再写一个循环，是这样的吗？
不是自身有循环，这样写只是定义一个字节数组作为一个缓存，临时存储输入流读取到的数据
如果你没加循环的话就只读1024Byte大小的数据。这样写应该是确定要读取的文件不超过1KB吧。
如果不确定读取的数据大小就要加循环了InputStream in = s.getInputStream();
         
byte[] buf = new byte[1024];
int len = -1;
while((len=in.read(buf))!=-1){
       //这里对读取到的数据进行处理
       // 比如这样
      String text = new String(buf, 0, len);
}OK 明白了，谢了我用在网络编程中，为什么会打出来乱码
InputStream in = s.getInputStream();
byte[] buf = new byte[9];
int len = 0;
StringBuffer sb = new StringBuffer();
while ((len = in.read(buf)) != -1) {
String str = new String(buf, 0, len);
sb.append(str);
}

System.out.println("ip = " + s.getInetAddress().getHostAddress());
System.out.println("data = " + sb);
System.out.println("port = " + ss.getLocalPort());
输出结果是：
服务器端启动...
ip = 10.1.52.112
data = 这是一个?丫谙氚?法 TCP 程序sfadasdf要在要在...
port = 10000
发送的数据是：
byte[] buf = new String("这是一个已经在想办法 TCP 程序sfadasdf要在要在...").getBytes();

Answer 7

就是说它自身就有循环，不需要自己再写一个循环，是这样的吗？
不是自身有循环，这样写只是定义一个字节数组作为一个缓存，临时存储输入流读取到的数据
如果你没加循环的话就只读1024Byte大小的数据。这样写应该是确定要读取的文件不超过1KB吧。
如果不确定读取的数据大小就要加循环了InputStream in = s.getInputStream();
         
byte[] buf = new byte[1024];
int len = -1;
while((len=in.read(buf))!=-1){
       //这里对读取到的数据进行处理
       // 比如这样
      String text = new String(buf, 0, len);
}OK 明白了，谢了我用在网络编程中，为什么会打出来乱码
InputStream in = s.getInputStream();
byte[] buf = new byte[9];
int len = 0;
StringBuffer sb = new StringBuffer();
while ((len = in.read(buf)) != -1) {
String str = new String(buf, 0, len);
sb.append(str);
}

System.out.println("ip = " + s.getInetAddress().getHostAddress());
System.out.println("data = " + sb);
System.out.println("port = " + ss.getLocalPort());
输出结果是：
服务器端启动...
ip = 10.1.52.112
data = 这是一个?丫谙氚?法 TCP 程序sfadasdf要在要在...
port = 10000
发送的数据是：
byte[] buf = new String("这是一个已经在想办法 TCP 程序sfadasdf要在要在...").getBytes();
这个涉及到编码问题了，
InputStream是字节流，也就是说它发送数据时是以字节的形式发送的，然后你用这种方式编码成字符串
String str = new String(buf, 0, len);
但是你的缓冲数组定的太小了，只有9个字节，造成了数组的最后可能存储的是一个汉字解码后的一部分字节，然后另外一部分被存到了下一个数组，组装成另外的字符串了，所以就出现了乱码