「java得出结果」java数据结果
今天给各位分享java得出结果的知识，其中也会对java数据结果进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、在Java中，如何通过在数据库得到的结果集得到表的列数和行数？
- 2、java 获取SQL查询语句返回的结果？
- 3、java用函数计算结果
- 4、java两个Integer中为什么得出的结果为false
- 5、输入两个数然后输入一个运算符计算出结果输出的JAVA程序怎么写？
- 6、输入运算公式 得到结果 java
在Java中，如何通过在数据库得到的结果集得到表的列数和行数？
在Java中，获得ResultSet的总行数的方法有以下几种。
第一种：利用ResultSet的getRow方法来获得ResultSet的总行数
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rset = stmt.executeQuery("select * from yourTableName");
rset.last();
int rowCount = rset.getRow(); //获得ResultSet的总行数
第二种：利用循环ResultSet的元素来获得ResultSet的总行数
ResultSet rset = stmt.executeQuery("select * from yourTableName");
int rowCount = 0;
while(rset.next()) {
rowCount++;}rowCount就是ResultSet的总行数。
(1)首先使用last()方法，将数据库游标定位到记录集的最后一行。
(2)使用getRow()方法，返回记录集最后一行的行索引。该索引就等于记录集所包含记录的个数，也就是记录集的行数。getRow()方法是在JDBC API 2.0中才定义的，在JDBC API 1.0中没有这个方法。
java 获取SQL查询语句返回的结果？
step1:构造连接\x0d\x0a Class.forName("com.mysql.jdbc.Driver"); \x0d\x0a Connection con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db","root","123"); \x0d\x0a\x0d\x0astep2:构造语句\x0d\x0aString sql = "select username,password from t_user where username=?"; \x0d\x0aPreparedStatement stmt = con.prepareStatement(sql); \x0d\x0astmt.setString(1, "zhangshan"); //给SQL的"?"（问号）传值。\x0d\x0a\x0d\x0astep3:执行查询\x0d\x0aResultSet rs = stmt.executeQuery(); //rs就是SQL查询语句返回的结果集\x0d\x0a\x0d\x0astep4:处理结果(java 获取SQL查询语句返回的结果)\x0d\x0a List list = new ArrayList();\x0d\x0a //遍历结果集，这样写就可以了，就是一个循环，有多少条记录，这里就会循环多少次，\x0d\x0a //一次就是一条记录，想像一下就像一个表的一条记录\x0d\x0a //在这里可以做查询出来的数据处理，可以封装成对象之类的（就是把值给它）\x0d\x0a if(rs.next()) { //遍历结果集，这样写就可以了\x0d\x0a User u = new User();\x0d\x0a String username = rs.getString("username"); \x0d\x0a String address = rs.getString("password "); \x0d\x0a u.setUsername(username);\x0d\x0a u.setAddress(address);\x0d\x0a list.add(u);\x0d\x0a } \x0d\x0a //上面这个例子意思是，把每一条记录封装成了一个User对象，然后这些User对象都放存入到了一个list\x0d\x0a\x0d\x0astep4:关闭连接等
java用函数计算结果
按照你的要求补全的Java程序如下：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Test30008{
public static void main(String args[]){
int repeat, ri,x;
double y;
Scanner in=new Scanner(System.in);
repeat=in.nextInt();
for(ri = 1; ri = repeat; ri++){
x=in.nextInt();
/*---------*/
if(x==0)y=0;
else y=1/(double)x;
DecimalFormat df=new DecimalFormat("#.00");
y=Double.parseDouble(df.format(y));
/*---------*/
System.out.println("f("+x+")="+y);
}
}
}
运行结果：
3
6
f(6)=0.17
10
f(10)=0.1
f(0)=0.0
java两个Integer中为什么得出的结果为false
当然是false了，因为你定义了两个Integer对象
i
和
j，“==”在用于两个对象之间比较时，比较的是两个对象的地址，而不是值。
i
和
j分别是两个Integer对象，在内存中的地址当然不一样，所以比较结果是false。
用int来定义的话，比较的就是值，结果就是true了。
输入两个数然后输入一个运算符计算出结果输出的JAVA程序怎么写？
import java.util.Scanner;\x0d\x0a\x0d\x0apublic class Test {\x0d\x0a public static void main(String[] args) {\x0d\x0a Scanner input=new Scanner(System.in);\x0d\x0a System.out.println("输入第一个数");\x0d\x0a double x=input.nextDouble();\x0d\x0a System.out.println("输入第二个数");\x0d\x0a double y=input.nextDouble();\x0d\x0a System.out.println("输入运算符");\x0d\x0a String op=input.next();\x0d\x0a if ("+".equals(op)) {\x0d\x0a System.out.println("结果是："+(x+y));\x0d\x0a }else if ("-".equals(op)) {\x0d\x0a System.out.println("结果是："+(x-y));\x0d\x0a }else if ("*".equals(op)) {\x0d\x0a System.out.println("结果是："+(x*y));\x0d\x0a }else if ("/".equals(op)) {\x0d\x0a System.out.println("结果是："+(x/y));\x0d\x0a }else {\x0d\x0a System.out.println("出现异常");\x0d\x0a }\x0d\x0a }\x0d\x0a\x0d\x0a}
输入运算公式 得到结果 java
通过栈实现,先用栈将中缀表达式转化为后缀表达式，然后再用栈计算后缀表达式的值的
package com.saturday;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyParse {
static MapString,Integer optrOrder;
static {
optrOrder=new HashMapString,Integer();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("#",3);
}
public static void main(String[] args){
ListString tokens;
try{
//词法分析
tokens=lex("+2* (-2+3*4)+-5");
//中缀转后缀
tokens=toRpn(tokens);
//计算结果
System.out.println(calcRpn(tokens));
}catch(Exception ex){
ex.printStackTrace();
}
}
/**
* 将输入串转换为操作符串
* @param sExpres
* @return
*/
public static ListString lex(String sExpres){
ListString tokens=new ArrayListString();
//将表达式分割成符号序列
String sRegExp="(((?=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}
tokens.add("#");
return tokens;
}
/**
* 将中缀表单时转化为后缀表达式
* @param tokens
* @return
*/
public static ListString toRpn(ListString tokens)
throws Exception{
ListString rpnList=new ArrayListString();
StackString optrStack=new StackString();
optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}
if(!optrStack.isEmpty()
optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("后缀表达式转化错误!");
}
}
/**
* 计算后缀表达式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(ListString rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
StackDouble numStack=new StackDouble();
for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf('+')==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}
if (!numStack.isEmpty() numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("计算错误！");
}
}
/**
* 将运算符输出到后缀表达式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
StackString optrStack,
ListString rpnList)
throws Exception{
String preOptr;
if(optr.equals("(")){//处理左括号
optrStack.push(optr);
return;
}
if(optr.equals(")")){//处理右括号
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}
if(optrStack.isEmpty()){
throw new Exception("括号未闭合!");
}
return;
}
/*按优先级处理其他运算符，若当前运算符优先级较高
* 直接入栈，否则将栈中运算符出战直至栈顶运算符
* 低于当前运算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
!optrStack.isEmpty()
optrCmp(optr,preOptr)=0){
preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}
/**
* 运算符优先级比较函数,optr1优先级大于optr2返回小于0值,
* 优先级相等返回0,optr1小于optr2返回大于0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}
/**
* 根据运算符对数据栈中的内容进行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
StackDouble numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();
if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}
关于java得出结果和java数据结果的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。