精华内容
下载资源
问答
  • 参考csdn论坛上写的。...读取末操作: public static String readendline(String filename) throws Exception { RandomAccessFile file0 = new RandomAccessFile(filename, "r"); long start = file0.g

    参考csdn论坛上写的。。。原文链接找不到了。。。


    注:有的地方视情况而定,比如nextend = start+len-1, 如果是空文件就会出错了可以把-1 去掉

    读取末行操作:


    public static String readendline(String filename) throws Exception {
    
    		RandomAccessFile file0 = new RandomAccessFile(filename, "r");
    		long start = file0.getFilePointer();
    		long len = file0.length();
    		long nextend = start + len - 1;
    		file0.seek(nextend);
    		byte buf[] = new byte[1];
    		int i = -1;
    		String linestr = null;
    		while (nextend > start) {
    			i = file0.read(buf, 0, 1);
    			if (buf[0] == '\n') {
    				if ((linestr = file0.readLine()) != null) {
    					 System.out.println("endline:" + linestr);
    					break;
    				}
    
    			}
    			nextend--;
    			file0.seek(nextend);
    		}
    
    		file0.close();
    		return linestr;
    
    	}
    }





    写末行,覆盖末行操作:

    	public static void writeendline(String filepath, String string)
    			throws Exception {
    
    		RandomAccessFile file = new RandomAccessFile(filepath, "rw");
    		long len = file.length();
    		long start = file.getFilePointer();
    		long nextend = start + len - 1;
    		byte[] buf = new byte[1];
    		file.seek(nextend);
    		file.read(buf, 0, 1);
    
    		if (buf[0] == '\n')
    
    			file.writeBytes(string);
    		else
    			
    			file.writeBytes("\r\n"+string);
    		
    		file.close();
    
    	}
    
    	public static void rewriteendline(String filepath, String string)
    			throws Exception {
    
    		RandomAccessFile file = new RandomAccessFile(filepath, "rw");
    		long len = file.length();
    		long start = file.getFilePointer();
    		long nextend = start + len - 1;
    
    		int i = -1;
    		file.seek(nextend);
    		byte[] buf = new byte[1];
    
    		while (nextend > start) {
    
    			i = file.read(buf, 0, 1);
    			if (buf[0] == '\r') {
    				file.setLength(nextend - start);
    				break;
    			}
    			nextend--;
    			file.seek(nextend);
    
    		}
    		file.close();
    		writeendline(filepath, string);
    
    	}


    展开全文
  • Java Serializable:明明就的接口嘛

    千次阅读 多人点赞 2019-06-21 11:29:59
    对于 Java 的序列化,我一直停留在最浅显的认知上——把那个要序列化的类实现 Serializbale 接口就可以了。...Java 序列化是 JDK 1.1 时引入的组开创性的特性,用于将 Java 对象转换为字节数组...

    对于 Java 的序列化,我一直停留在最浅显的认知上——把那个要序列化的类实现 Serializbale 接口就可以了。我不愿意做更深入的研究,因为会用就行了嘛。

    但随着时间的推移,见到 Serializbale 的次数越来越多,我便对它产生了浓厚的兴趣。是时候花点时间研究研究了。

    01、先来点理论

    Java 序列化是 JDK 1.1 时引入的一组开创性的特性,用于将 Java 对象转换为字节数组,便于存储或传输。此后,仍然可以将字节数组转换回 Java 对象原有的状态。

    序列化的思想是“冻结”对象状态,然后写到磁盘或者在网络中传输;反序列化的思想是“解冻”对象状态,重新获得可用的 Java 对象。

    再来看看序列化 Serializbale 接口的定义:

    public interface Serializable {
    }
    

    明明就一个空的接口嘛,竟然能够保证实现了它的“类的对象”被序列化和反序列化?

    02、再来点实战

    在回答上述问题之前,我们先来创建一个类(只有两个字段,和对应的 getter/setter),用于序列化和反序列化。

    class Wanger {
        private String name;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    再来创建一个测试类,通过 ObjectOutputStream 将“18 岁的王二”写入到文件当中,实际上就是一种序列化的过程;再通过 ObjectInputStream 将“18 岁的王二”从文件中读出来,实际上就是一种反序列化的过程。

    public class Test {
    
        public static void main(String[] args) {
          // 初始化
            Wanger wanger = new Wanger();
            wanger.setName("王二");
            wanger.setAge(18);
            System.out.println(wanger);
    
            // 把对象写到文件中
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){
                oos.writeObject(wanger);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 从文件中读出对象
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){
                Wanger wanger1 = (Wanger) ois.readObject();
                System.out.println(wanger1);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    不过,由于 Wanger 没有实现 Serializbale 接口,所以在运行测试类的时候会抛出异常,堆栈信息如下:

    java.io.NotSerializableException: com.cmower.java_demo.xuliehua.Wanger
    	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
    	at com.cmower.java_demo.xuliehua.Test.main(Test.java:21)
    

    顺着堆栈信息,我们来看一下 ObjectOutputStreamwriteObject0() 方法。其部分源码如下:

    if (obj instanceof String) {
        writeString((String) obj, unshared);
    } else if (cl.isArray()) {
        writeArray(obj, desc, unshared);
    } else if (obj instanceof Enum) {
        writeEnum((Enum<?>) obj, desc, unshared);
    } else if (obj instanceof Serializable) {
        writeOrdinaryObject(obj, desc, unshared);
    } else {
        if (extendedDebugInfo) {
            throw new NotSerializableException(
                cl.getName() + "\n" + debugInfoStack.toString());
        } else {
            throw new NotSerializableException(cl.getName());
        }
    }
    

    也就是说,ObjectOutputStream 在序列化的时候,会判断被序列化的对象是哪一种类型,字符串?数组?枚举?还是 Serializable,如果全都不是的话,抛出 NotSerializableException

    假如 Wanger 实现了 Serializable 接口,就可以序列化和反序列化了。

    class Wanger implements Serializable{
        private static final long serialVersionUID = -2095916884810199532L;
        
        private String name;
        private int age;
    }
    

    具体怎么序列化呢?

    ObjectOutputStream 为例吧,它在序列化的时候会依次调用 writeObject()writeObject0()writeOrdinaryObject()writeSerialData()invokeWriteObject()defaultWriteFields()

    private void defaultWriteFields(Object obj, ObjectStreamClass desc)
            throws IOException
        {
            Class<?> cl = desc.forClass();
            desc.checkDefaultSerialize();
    
            int primDataSize = desc.getPrimDataSize();
            desc.getPrimFieldValues(obj, primVals);
            bout.write(primVals, 0, primDataSize, false);
    
            ObjectStreamField[] fields = desc.getFields(false);
            Object[] objVals = new Object[desc.getNumObjFields()];
            int numPrimFields = fields.length - objVals.length;
            desc.getObjFieldValues(obj, objVals);
            for (int i = 0; i < objVals.length; i++) {
              
                try {
                    writeObject0(objVals[i],
                                 fields[numPrimFields + i].isUnshared());
                }
            }
        }
    

    那怎么反序列化呢?

    ObjectInputStream 为例,它在反序列化的时候会依次调用 readObject()readObject0()readOrdinaryObject()readSerialData()defaultReadFields()

    private void defaultWriteFields(Object obj, ObjectStreamClass desc)
            throws IOException
        {
            Class<?> cl = desc.forClass();
            desc.checkDefaultSerialize();
    
            int primDataSize = desc.getPrimDataSize();
            desc.getPrimFieldValues(obj, primVals);
            bout.write(primVals, 0, primDataSize, false);
    
            ObjectStreamField[] fields = desc.getFields(false);
            Object[] objVals = new Object[desc.getNumObjFields()];
            int numPrimFields = fields.length - objVals.length;
            desc.getObjFieldValues(obj, objVals);
            for (int i = 0; i < objVals.length; i++) {
              
                try {
                    writeObject0(objVals[i],
                                 fields[numPrimFields + i].isUnshared());
                }
            }
        }
    

    我想看到这,你应该会恍然大悟的“哦”一声了。Serializable 接口之所以定义为空,是因为它只起到了一个标识的作用,告诉程序实现了它的对象是可以被序列化的,但真正序列化和反序列化的操作并不需要它来完成。

    03、再来点注意事项

    开门见山的说吧,statictransient 修饰的字段是不会被序列化的。

    为什么呢?我们先来证明,再来解释原因。

    首先,在 Wanger 类中增加两个字段。

    class Wanger implements Serializable {
        private static final long serialVersionUID = -2095916884810199532L;
    
        private String name;
        private int age;
    
        public static String pre = "沉默";
        transient String meizi = "王三";
    
        @Override
        public String toString() {
            return "Wanger{" + "name=" + name + ",age=" + age + ",pre=" + pre + ",meizi=" + meizi + "}";
        }
    }
    

    其次,在测试类中打印序列化前和反序列化后的对象,并在序列化后和反序列化前改变 static 字段的值。具体代码如下:

    // 初始化
    Wanger wanger = new Wanger();
    wanger.setName("王二");
    wanger.setAge(18);
    System.out.println(wanger);
    
    // 把对象写到文件中
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));){
            oos.writeObject(wanger);
        } catch (IOException e) {
            e.printStackTrace();
        }
       
        // 改变 static 字段的值
    Wanger.pre ="不沉默";
    
    // 从文件中读出对象
    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));){
        Wanger wanger1 = (Wanger) ois.readObject();
        System.out.println(wanger1);
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    // Wanger{name=王二,age=18,pre=沉默,meizi=王三}
    // Wanger{name=王二,age=18,pre=不沉默,meizi=null}
    
    

    从结果的对比当中,我们可以发现:

    1)序列化前,pre 的值为“沉默”,序列化后,pre 的值修改为“不沉默”,反序列化后,pre 的值为“不沉默”,而不是序列化前的状态“沉默”。

    为什么呢?因为序列化保存的是对象的状态,而 static 修饰的字段属于类的状态,因此可以证明序列化并不保存 static 修饰的字段。

    2)序列化前,meizi 的值为“王三”,反序列化后,meizi 的值为 null,而不是序列化前的状态“王三”。

    为什么呢?transient 的中文字义为“临时的”(论英语的重要性),它可以阻止字段被序列化到文件中,在被反序列化后,transient 字段的值被设为初始值,比如 int 型的初始值为 0,对象型的初始值为 null

    如果想要深究源码的话,你可以在 ObjectStreamClass 中发现下面这样的代码:

    private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
        Field[] clFields = cl.getDeclaredFields();
        ArrayList<ObjectStreamField> list = new ArrayList<>();
        int mask = Modifier.STATIC | Modifier.TRANSIENT;
    
        int size = list.size();
        return (size == 0) ? NO_FIELDS :
            list.toArray(new ObjectStreamField[size]);
    }
    

    看到 Modifier.STATIC | Modifier.TRANSIENT,是不是感觉更好了呢?

    04、再来点干货

    除了 Serializable 之外,Java 还提供了一个序列化接口 Externalizable(念起来有点拗口)。

    两个接口有什么不一样的吗?试一试就知道了。

    首先,把 Wanger 类实现的接口 Serializable 替换为 Externalizable

    class Wanger implements Externalizable {
    	private String name;
    	private int age;
    
    	public Wanger() {
    
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	
    	@Override
    	public String toString() {
    		return "Wanger{" + "name=" + name + ",age=" + age + "}";
    	}
    
    	@Override
    	public void writeExternal(ObjectOutput out) throws IOException {
    
    	}
    
    	@Override
    	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    
    	}
    
    }
    

    实现 Externalizable 接口的 Wanger 类和实现 Serializable 接口的 Wanger 类有一些不同:

    1)新增了一个无参的构造方法。

    使用 Externalizable 进行反序列化的时候,会调用被序列化类的无参构造方法去创建一个新的对象,然后再将被保存对象的字段值复制过去。否则的话,会抛出以下异常:

    java.io.InvalidClassException: com.cmower.java_demo.xuliehua1.Wanger; no valid constructor
    	at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
    	at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)
    	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)
    	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
    	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
    	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
    

    2)新增了两个方法 writeExternal()readExternal(),实现 Externalizable 接口所必须的。

    然后,我们再在测试类中打印序列化前和反序列化后的对象。

    // 初始化
    Wanger wanger = new Wanger();
    wanger.setName("王二");
    wanger.setAge(18);
    System.out.println(wanger);
    
    // 把对象写到文件中
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {
    	oos.writeObject(wanger);
    } catch (IOException e) {
    	e.printStackTrace();
    }
    
    // 从文件中读出对象
    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {
    	Wanger wanger1 = (Wanger) ois.readObject();
    	System.out.println(wanger1);
    } catch (IOException | ClassNotFoundException e) {
    	e.printStackTrace();
    }
    // Wanger{name=王二,age=18}
    // Wanger{name=null,age=0}
    

    从输出的结果看,反序列化后得到的对象字段都变成了默认值,也就是说,序列化之前的对象状态没有被“冻结”下来。

    为什么呢?因为我们没有为 Wanger 类重写具体的 writeExternal()readExternal() 方法。那该怎么重写呢?

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
    	out.writeObject(name);
    	out.writeInt(age);
    }
    
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    	name = (String) in.readObject();
    	age = in.readInt();
    }
    

    1)调用 ObjectOutputwriteObject() 方法将字符串类型的 name 写入到输出流中;

    2)调用 ObjectOutputwriteInt() 方法将整型的 age 写入到输出流中;

    3)调用 ObjectInputreadObject() 方法将字符串类型的 name 读入到输入流中;

    4)调用 ObjectInputreadInt() 方法将字符串类型的 age 读入到输入流中;

    再运行一次测试了类,你会发现对象可以正常地序列化和反序列化了。

    序列化前:Wanger{name=王二,age=18}
    序列化后:Wanger{name=王二,age=18}

    05、再来点甜点

    让我先问问你吧,你知道 private static final long serialVersionUID = -2095916884810199532L; 这段代码的作用吗?

    嗯…

    serialVersionUID 被称为序列化 ID,它是决定 Java 对象能否反序列化成功的重要因子。在反序列化时,Java 虚拟机会把字节流中的 serialVersionUID 与被序列化类中的 serialVersionUID 进行比较,如果相同则可以进行反序列化,否则就会抛出序列化版本不一致的异常。

    当一个类实现了 Serializable 接口后,IDE 就会提醒该类最好产生一个序列化 ID,就像下面这样:

    1)添加一个默认版本的序列化 ID:

    private static final long serialVersionUID = 1L。
    

    2)添加一个随机生成的不重复的序列化 ID。

    private static final long serialVersionUID = -2095916884810199532L;
    

    3)添加 @SuppressWarnings 注解。

    @SuppressWarnings("serial")
    

    怎么选择呢?

    首先,我们采用第二种办法,在被序列化类中添加一个随机生成的序列化 ID。

    class Wanger implements Serializable {
    	private static final long serialVersionUID = -2095916884810199532L;
    	
    	private String name;
    	private int age;
    
    	// 其他代码忽略
    }
    

    然后,序列化一个 Wanger 对象到文件中。

    // 初始化
    Wanger wanger = new Wanger();
    wanger.setName("王二");
    wanger.setAge(18);
    System.out.println(wanger);
    
    // 把对象写到文件中
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("chenmo"));) {
    	oos.writeObject(wanger);
    } catch (IOException e) {
    	e.printStackTrace();
    }
    

    这时候,我们悄悄地把 Wanger 类的序列化 ID 偷梁换柱一下,嘿嘿。

    // private static final long serialVersionUID = -2095916884810199532L;
    private static final long serialVersionUID = -2095916884810199533L;
    

    好了,准备反序列化吧。

    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("chenmo")));) {
    	Wanger wanger = (Wanger) ois.readObject();
    	System.out.println(wanger);
    } catch (IOException | ClassNotFoundException e) {
    	e.printStackTrace();
    }
    

    哎呀,出错了。

    java.io.InvalidClassException:  local class incompatible: stream classdesc 
    serialVersionUID = -2095916884810199532,
    local class serialVersionUID = -2095916884810199533
    	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
    	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
    

    异常堆栈信息里面告诉我们,从持久化文件里面读取到的序列化 ID 和本地的序列化 ID 不一致,无法反序列化。

    那假如我们采用第三种方法,为 Wanger 类添加个 @SuppressWarnings("serial") 注解呢?

    @SuppressWarnings("serial")
    class Wanger implements Serializable {
    // 省略其他代码
    }
    

    好了,再来一次反序列化吧。可惜依然报错。

    java.io.InvalidClassException:  local class incompatible: stream classdesc 
    serialVersionUID = -2095916884810199532, 
    local class serialVersionUID = -3818877437117647968
    	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
    	at com.cmower.java_demo.xuliehua1.Test.main(Test.java:27)
    

    异常堆栈信息里面告诉我们,本地的序列化 ID 为 -3818877437117647968,和持久化文件里面读取到的序列化 ID 仍然不一致,无法反序列化。这说明什么呢?使用 @SuppressWarnings("serial") 注解时,该注解会为被序列化类自动生成一个随机的序列化 ID。

    由此可以证明,Java 虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,还有一个非常重要的因素就是序列化 ID 是否一致。

    也就是说,如果没有特殊需求,采用默认的序列化 ID(1L)就可以,这样可以确保代码一致时反序列化成功。

    class Wanger implements Serializable {
    	private static final long serialVersionUID = 1L;
    // 省略其他代码
    }
    

    06、再来点总结

    写这篇文章之前,我真没想到:“空空其身”的Serializable 竟然有这么多可以研究的内容!

    写完这篇文章之后,我不由得想起理科状元曹林菁说说过的一句话:“在学习中再小的问题也不放过,每个知识点都要总结”——说得真真真真的对啊!

    PS:欢迎关注「沉默王二」公众号,后台回复关键字「2048」,即可免费获取「1W+程序员领取的进阶必读资料包」!!

    展开全文
  • Java 2代码写指针异常(NPE)

    千次阅读 2018-01-28 20:59:57
    String str = null; str.toString();

    String str = null;
    str.toString();


    展开全文
  • 使用Java在文件里插入一行

    千次阅读 2014-08-06 16:55:06
    在文件里增加一行的唯一方法就是读取原始文件,然后写入到一个临时文件,同时写入要插入的数据。然后删除原始文件,再把临时文件改名为原始文件名。 package net.java2000.io;import java.io....
    在文件里增加一行的唯一方法就是读取原始文件,然后写入到一个临时文件,同时写入要插入的数据。然后删除原始文件,再把临时文件改名为原始文件名。
    

    1. package net.java2000.io;
    2. import java.io.BufferedReader;
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6. import java.io.InputStreamReader;
    7. import java.io.PrintWriter;
    8. /**
    9.  * 给文件增加一行数据。
    10.  * 
    11.  * @author 赵学庆,Java世纪网(java2000.net)
    12.  * 
    13.  */
    14. public class FileInsertRow {
    15.   public static void main(String args[]) {
    16.     try {
    17.       FileInsertRow j = new FileInsertRow();
    18.       j.insertStringInFile(new File(args[0]), Integer.parseInt(args[1]), args[2]);
    19.     } catch (Exception e) {
    20.       e.printStackTrace();
    21.     }
    22.   }
    23.   /**
    24.    * 在文件里面的指定行插入一行数据
    25.    * 
    26.    * @param inFile
    27.    *          文件
    28.    * @param lineno
    29.    *          行号
    30.    * @param lineToBeInserted
    31.    *          要插入的数据
    32.    * @throws Exception
    33.    *           IO操作引发的异常
    34.    */
    35.   public void insertStringInFile(File inFile, int lineno, String lineToBeInserted)
    36.       throws Exception {
    37.     // 临时文件
    38.     File outFile = File.createTempFile("name"".tmp");
    39.     // 输入
    40.     FileInputStream fis = new FileInputStream(inFile);
    41.     BufferedReader in = new BufferedReader(new InputStreamReader(fis));
    42.     // 输出
    43.     FileOutputStream fos = new FileOutputStream(outFile);
    44.     PrintWriter out = new PrintWriter(fos);
    45.     // 保存一行数据
    46.     String thisLine;
    47.     // 行号从1开始
    48.     int i = 1;
    49.     while ((thisLine = in.readLine()) != null) {
    50.       // 如果行号等于目标行,则输出要插入的数据
    51.       if (i == lineno) {
    52.         out.println(lineToBeInserted);
    53.       }
    54.       // 输出读取到的数据
    55.       out.println(thisLine);
    56.       // 行号增加
    57.       i++;
    58.     }
    59.     out.flush();
    60.     out.close();
    61.     in.close();
    62.     // 删除原始文件
    63.     inFile.delete();
    64.     // 把临时文件改名为原文件名
    65.     outFile.renameTo(inFile);
    66.   }
    67. }
    展开全文
  • 我有个大学校友,他是去年 8 月份才开始正式学习 Java 的,之前在一家私企工作了 5 年,工资个月只有不到 6000 块,日子过得很苦逼,毕竟郑州的房贷压力也不小,公司就那么大,除非领导离职,否则根本看不到晋升...
  • Java分布式锁(一行代码搞定)

    千次阅读 2018-06-20 17:49:50
    Java分布式锁(一行代码搞定) 前面几篇文章都是介绍的java单机锁,但是目前很多应用都是分布式的(不同jvm进程),单机锁已经不能满足应用的需求了...
  • 你真的懂Java怎么输出Hello World吗?

    万次阅读 多人点赞 2021-06-09 22:00:57
    你真的懂Java怎么输出Hello World吗?1. 你会不会输出"Hello World!"?2. 小生抛砖引玉,欢迎指正3. 总结 1. 你会不会输出"Hello World!"? 当我们学习一门编程语言的时候,我们都会先学如何输出Hello World! ????...
  • java读取文件中的每一行

    万次阅读 2017-06-21 11:08:06
    转自:...import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import
  • java如何判断个excel,word,ppt是否为的文档
  • @java IDEA 指针异常断点如何打详解java.lang.NullPointerException # java IDEA指针异常java.lang.NullPointerException断点如何打详解java.lang.NullPointerException 1、点击图中红点,可查看所有断点;; 2...
  • 指针异常产生的主要原因如下: (1)当个对象不存在时又调用其方法会产生异常obj.method() // obj对象不存在 (2)当访问或修改个对象不存在的字段时会产生异常obj.method() // method方法不存在 (3)字符...
  • java基础入门(

    万次阅读 多人点赞 2018-04-28 21:43:43
    2. 这篇教程是个学习方向的引导,且只针对基础入门(更加进阶的知识笔者也还在学习)。 3. java的基础入门知识网上有很多,很多大神的博客里也有总结,笔者不认为自己能比大神总结的好。所以在这篇教程里,...
  • Java实现输出前100个素数,并且5个一行
  • java读取txt文件第一行遇到的问题

    千次阅读 2017-12-20 14:46:01
    场景:今天在用java字符流读取类似下图的txt文件:目标是将每一行的内容通过’,’分割,分别转化为int和String类型并保存,读取代码如下:File file = new File("C:\\Users\\liuwi\\Desktop\\百度城市信息.txt");...
  • java获得excel最后一列,最后一行

    千次阅读 2018-08-23 13:34:48
    最近遇到个需求是需要向excel表格中追加数据,由于报表格式要求需要按列添加,因此需要获得excel表格最后列值,然后列插入值: private static int findRealCloumns(XSSFSheet sheet, int... flag) {  int ...
  • JAVA读入一行空格隔开的数据

    千次阅读 2016-03-24 21:53:44
    直接上干货:import java.util.Scanner;public class Test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String s = sc.nextLine(); String ss[] = s.sp
  • 简介:CSDN博客专家,从事软件开发多年,精通Java、JavaScript,博主也是从零开始步步把学习成长、深知学习和积累的重要性,喜欢跟广大ADC一起打野升级,欢迎您关注,期待与您一起学习、成长、起飞! 系列目录 1....
  • java打印空白金字塔

    千次阅读 2019-05-06 13:20:25
    打印个空白金字塔 如图 代码如下: public class jinzita { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入需要打印的层数:"); int n=...
  • Java用IO读取文件中的字符串,第一个字符是字符,如果要截取字符串的第一个字符,得到的是的,所以必须先对第一行字符串进行处理,去掉第一个字符,然后再进行相应操作。...
  • 使用poi导入时候,就是excel里面有空值的时候整个方法都会报错(指针异常),下面是我的助理方式:
  • 转:http://blog.chinaunix.net/uid-20804770-id-3048513.htmlimport java.io....import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileNotFoundException;import java...
  • //当前这行全部为或者空格就忽视当前这行 if (isAllRowEmpty(row,sheet.getRow(0))){ continue; } ... * @param firstRow 第一行标题行 * @return */ public static boolean isAllRo...
  • Java 泛型,你了解类型擦除吗?

    万次阅读 多人点赞 2017-08-05 22:32:18
    泛型是 Java 中一个很小巧的概念,但同时也是个很容易让人迷惑的知识点,它让人迷惑的地方在于它的许多表现有点违反直觉。文章开始的地方,先给大家奉上一道经典的测试题。List&lt;String&gt; l1 = new ...
  • 实际应用中,经常会用到判断字符串是否为的逻辑 比较简单的就是用 Str != null &amp;&amp; Str.length() &gt;0 来判断 其实很多java工具集都是有包装好的接口可以使用的 比如 StringUtils....
  • 一行代码判断String字符串是否为纯符号 最近项目中新加的需求 我感觉我的构思很好,分享给大家 原理: 1.将String去除前后空格 2.将String中所有符号替换为 3.判断String长度(如全被替换,则长度为0) 举例:...
  • 当子类继承父类时,尽管我们没有显式的调用父类的参构造器,但是编译器会默认在子类的构造方法前的第一行添加super()调用父类的参构造器。 但是,当我们修改子类的默认的无参构造器的时候,这时候子类就没有了...
  • Java 枚举(enum) 详解7种常见的用法

    万次阅读 多人点赞 2016-08-11 11:14:45
    Java中它虽然算个“小”功能,却给我的开发带来了“大”方便。 大师兄我【大师兄】又加上自己的理解,来帮助各位理解一下。 用法:常量 在JDK1.5之前,我们定义常量都是:public static final....。现在好了...
  • 1,判断读入的String是否为字符串 要判读String是否为字符串,比较简单,只要判断该String的length是否为0就可以,或者直接用方法isEmpty()来判断。  但很多时候我们也会把由一些不可见的字符组成的String也...
  • Java判断字符串是否为

    万次阅读 2018-04-13 10:56:42
    思路:判断某字符串是否为,为的标准是str==null或str.length()==0.字符串与null区别1、类型null表示的是个对象的值,而并不是个字符串。例如声明个对象的引用,String a = null ;""表示的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,699
精华内容 153,079
关键字:

java必须空一行吗

java 订阅