Java编程语言之equal与 == 的区别

在开发的时候碰到一个空指针的问题,经过千辛万苦发现时NULL与str用equal()方法的时候报错导致。

特意分析了下equals 和 == 的区别以及在什么情况下使用equals,而在什么情况下使用==。

=============================我是分割线================================


大家都知道:

1.基本数据类型存储在栈中。

2.引用数据类型有两部分,本身存在堆中,它的地址存储在栈中。


当对两个变量进行比较的时候:

1.如果两个都是基本数据类型,则通过==来比较他们的值来判定是否内容一样。

注意:基本类型包括byte,short,char,int,long,float,double,boolean。


2.如果两个都是引用数据类型,则通过equals来比较他们的首地址是否相同来判断他们内容是否一样。
注意:如果是使用equals进行判断,需要自己重写equals,否则系统会调用父类object中的equals方法,这样和==判断就没有不同,容易出错。

通过上述会发现:当equals 返回true的时候 ,== 的判断并不会是true


下面通过一个实例来说明问题:

public class demo 
{
	public static void main(String[] args)
	{
		String str1 = "Hello";
		String str2 = new String("Hello");
		if(str1 == str2)
		{
		System.out.println("str1 == str2");
		}
		else 
		{
		System.out.println("str1 != str2");
		}
		if(str1.equals(str2))
		{
		System.out.println("str1 equals str2");
		}
		else
		{
		System.out.println("str1 not equals str2");
		}
	}
}

输出如下:str1 !=str2 str1 equals str2


原因分析:str1 和 str2 是对不同对象的引用,所以用==判断的话,栈中的值不同,但是用equals判断,返回true


以上仅是个人观点,欢迎大家交流,如有问题,请留言,我会在第一时间回复。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用Java语言编写的PL/0编译程序的语法分析程序: ```java import java.util.ArrayList; import java.util.List; import java.util.Stack; public class Parser { private Lexer lexer; private Token currentToken; private Stack<Integer> jumpStack; private int codePointer; private List<Instruction> instructions; public Parser(Lexer lexer) { this.lexer = lexer; this.currentToken = lexer.getNextToken(); this.jumpStack = new Stack<>(); this.codePointer = 0; this.instructions = new ArrayList<>(); } public List<Instruction> parse() { program(); return instructions; } private void program() { block(); match(TokenType.PERIOD); } private void block() { if (currentToken.getType() == TokenType.CONST) { constDeclaration(); } if (currentToken.getType() == TokenType.VAR) { varDeclaration(); } while (currentToken.getType() == TokenType.PROCEDURE) { procedureDeclaration(); } statement(); } private void constDeclaration() { match(TokenType.CONST); do { String name = currentToken.getValue(); match(TokenType.IDENTIFIER); match(TokenType.EQUAL); int value = Integer.parseInt(currentToken.getValue()); match(TokenType.NUMBER); instructions.add(new Instruction(Operation.LIT, value)); instructions.add(new Instruction(Operation.STO, SymbolTable.addSymbol(name))); } while (currentToken.getType() == TokenType.COMMA); match(TokenType.SEMICOLON); } private void varDeclaration() { match(TokenType.VAR); do { String name = currentToken.getValue(); match(TokenType.IDENTIFIER); instructions.add(new Instruction(Operation.INT, SymbolTable.addSymbol(name))); } while (currentToken.getType() == TokenType.COMMA); match(TokenType.SEMICOLON); } private void procedureDeclaration() { match(TokenType.PROCEDURE); String name = currentToken.getValue(); match(TokenType.IDENTIFIER); match(TokenType.SEMICOLON); int procedurePointer = codePointer; instructions.add(null); block(); instructions.add(new Instruction(Operation.RET, 0)); instructions.set(procedurePointer, new Instruction(Operation.JMP, codePointer)); SymbolTable.addSymbol(name, procedurePointer); match(TokenType.SEMICOLON); } private void statement() { if (currentToken.getType() == TokenType.IDENTIFIER) { String name = currentToken.getValue(); match(TokenType.IDENTIFIER); if (currentToken.getType() == TokenType.ASSIGN) { match(TokenType.ASSIGN); expression(); instructions.add(new Instruction(Operation.STO, SymbolTable.getSymbol(name))); } else { callStatement(name); } } else if (currentToken.getType() == TokenType.BEGIN) { match(TokenType.BEGIN); statement(); while (currentToken.getType() == TokenType.SEMICOLON) { match(TokenType.SEMICOLON); statement(); } match(TokenType.END); } else if (currentToken.getType() == TokenType.IF) { match(TokenType.IF); condition(); match(TokenType.THEN); int falseJumpPointer = instructions.size(); instructions.add(null); statement(); if (currentToken.getType() == TokenType.ELSE) { match(TokenType.ELSE); int endJumpPointer = instructions.size(); instructions.add(null); instructions.set(falseJumpPointer, new Instruction(Operation.JPF, codePointer)); statement(); instructions.set(endJumpPointer, new Instruction(Operation.JMP, codePointer)); } else { instructions.set(falseJumpPointer, new Instruction(Operation.JPF, codePointer)); } } else if (currentToken.getType() == TokenType.WHILE) { match(TokenType.WHILE); int loopStartPointer = codePointer; condition(); match(TokenType.DO); int falseJumpPointer = instructions.size(); instructions.add(null); statement(); instructions.add(new Instruction(Operation.JMP, loopStartPointer)); instructions.set(falseJumpPointer, new Instruction(Operation.JPF, codePointer)); } else if (currentToken.getType() == TokenType.CALL) { match(TokenType.CALL); String name = currentToken.getValue(); match(TokenType.IDENTIFIER); callStatement(name); } else if (currentToken.getType() == TokenType.READ) { match(TokenType.READ); String name = currentToken.getValue(); match(TokenType.IDENTIFIER); instructions.add(new Instruction(Operation.RED, SymbolTable.getSymbol(name))); } else if (currentToken.getType() == TokenType.WRITE) { match(TokenType.WRITE); expression(); instructions.add(new Instruction(Operation.WRT, 0)); } } private void expression() { TokenType operator = currentToken.getType(); if (operator == TokenType.PLUS || operator == TokenType.MINUS) { match(operator); } term(); while (currentToken.getType() == TokenType.PLUS || currentToken.getType() == TokenType.MINUS) { operator = currentToken.getType(); match(operator); term(); if (operator == TokenType.PLUS) { instructions.add(new Instruction(Operation.ADD, 0)); } else { instructions.add(new Instruction(Operation.SUB, 0)); } } } private void term() { factor(); while (currentToken.getType() == TokenType.TIMES || currentToken.getType() == TokenType.DIVIDE) { TokenType operator = currentToken.getType(); match(operator); factor(); if (operator == TokenType.TIMES) { instructions.add(new Instruction(Operation.MUL, 0)); } else { instructions.add(new Instruction(Operation.DIV, 0)); } } } private void factor() { if (currentToken.getType() == TokenType.NUMBER) { int value = Integer.parseInt(currentToken.getValue()); match(TokenType.NUMBER); instructions.add(new Instruction(Operation.LIT, value)); } else if (currentToken.getType() == TokenType.IDENTIFIER) { String name = currentToken.getValue(); match(TokenType.IDENTIFIER); instructions.add(new Instruction(Operation.LOD, SymbolTable.getSymbol(name))); } else if (currentToken.getType() == TokenType.LPAREN) { match(TokenType.LPAREN); expression(); match(TokenType.RPAREN); } else { throw new RuntimeException("Invalid factor: " + currentToken.getValue()); } } private void condition() { if (currentToken.getType() == TokenType.ODD) { match(TokenType.ODD); expression(); instructions.add(new Instruction(Operation.ODD, 0)); } else { expression(); TokenType operator = currentToken.getType(); relationalOperator(); expression(); if (operator == TokenType.EQUAL) { instructions.add(new Instruction(Operation.EQL, 0)); } else if (operator == TokenType.NOT_EQUAL) { instructions.add(new Instruction(Operation.NEQ, 0)); } else if (operator == TokenType.LESS_THAN) { instructions.add(new Instruction(Operation.LES, 0)); } else if (operator == TokenType.LESS_THAN_OR_EQUAL) { instructions.add(new Instruction(Operation.LEQ, 0)); } else if (operator == TokenType.GREATER_THAN) { instructions.add(new Instruction(Operation.GTR, 0)); } else if (operator == TokenType.GREATER_THAN_OR_EQUAL) { instructions.add(new Instruction(Operation.GEQ, 0)); } } } private void relationalOperator() { TokenType operator = currentToken.getType(); if (operator == TokenType.EQUAL || operator == TokenType.NOT_EQUAL || operator == TokenType.LESS_THAN || operator == TokenType.LESS_THAN_OR_EQUAL || operator == TokenType.GREATER_THAN || operator == TokenType.GREATER_THAN_OR_EQUAL) { match(operator); } else { throw new RuntimeException("Invalid relational operator: " + currentToken.getValue()); } } private void callStatement(String name) { instructions.add(new Instruction(Operation.CAL, SymbolTable.getSymbol(name))); } private void match(TokenType expectedType) { if (currentToken.getType() == expectedType) { currentToken = lexer.getNextToken(); } else { throw new RuntimeException("Invalid token: " + currentToken.getValue() + ". Expected " + expectedType.toString()); } } } ``` 此程序使用递归下降方法进行语法分析,并将生成的指令保存在一个列表。其包括各种声明(常量、变量和过程)、语句(赋值、条件、循环、调用、读入和输出)和表达式(加减乘除和关系运算)。在处理过程,还要维护符号表和跳转指令的位置。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值