java返回list
‘壹’ java如何得到一个方法返回的list
你是java的初学者吧，java一个方法的最基本的声明，由修饰符，返回值，方法名组成，这是必要的三个元素。最简单的方法也要由这三个部分组成，比如一个简单的方法
public void test(){
system.out.println("Hello World");
}
这里public是修饰符，表示是公共的方法，void表示返回值，void为空，表示这个方法不需要返回值，test是方法名，小括号里是方法的参数，没有即不需要参数，花括号为具体的java代码，也就是方法执行的过程。这里是直接在控制太输出Hello World这个句子。
回到你的问题，一个方法要返回List，即表示这个方法的返回值为List，那么遵循我最开始说的方法组成，这里的返回值就是List，所以把void 改成List即可。写个完整的例子，一个方法返回一个包含整数1~10的List。
public List getNumberList(){
List list=new ArrayList();
for(int i=1;i<=10;i++){
list.add(i);
}
return list;
}
此处方法返回值声明为List，即表示这个方法必须返回一个List，不返回List，至少要返回一个Null，因为java的方法，只要返回值不为void，都必须返回一个对象。
希望我的回答能帮到你~~
‘贰’ java查询某两个字段返回list列表,
查询某几列时返回的结果是装有object数组的list
List<Object[]> list=SightdemoDao.querysightdemo(detilParam);
for(int i=0;i<list.size();i++){
Object[] le=list.get(i);
System.out.println(le[0]);
System.out.println(le[1]);
}
‘叁’ java 用返回的list去查询数据库,返回list
分析你的逻辑应该如下：
1、查询表1中符合条件的信息，获取一个结果集合1；
2、基于结果集合1循环，检索表2，获取结果集合2。
如此，如果表1、表2间存在直接关联关系（即直接使用结果集合1中的部分信息作为表2查询的条件），那么完全可以在后台将两张表关联查询，这样避免了通过java进行循环，在大数量级情况下会严重占用内存。
如果表1，表2间没有直接的关联关系（即通过循环表1，判断其中条件后按照其它的特定对照值去查询表2），那么仍然建议使用后台表关联查询，及将表1查询的结果集按照不同的条件获取的值转换成对应的映射值后作为一个基准集合，然后将这个集合与表2关联查询即可。具体的sql语句，得根据你使用的数据库和具体场景去编写。
总之，此类情况，完全可以交由数据库搞定，如果使用你现在的逻辑（即查询表1，循环结果集1，然后查询表2，获取结果集2），虽然原则上没有错，但会增加很多内存开销，在大数据量级的情况下，非常容易出现内存溢出的异常，并不作为合理的编码方式。
‘肆’ JAVA 定义方法里，前面是list类型，那么返回应该是什么
这个方法应该返回list塞，，
把log对象放到list中，然后返回list就OK 。
这样放。
ArrayList list=new ArrayList();
while(rs.next()){
log=new Log();
log.setId(rs.getInt(1));
log.setLog_title(rs.getString(2));
log.setLog_content(rs.getString(3));
log.setLog_date(rs.getDate(4));
log.setRemark(rs.getString(5));
list.add(log);//把log放到list.
}
return list;
‘伍’ Java方法返回list<e>是什么情况
返回list<e>,就是 “返回一个对象集合” 字太小看不太清楚，你这代码应该没有问题吧。应该是其他地方冲突了。上面报错会告诉你为什么报错啊，把报错的内容贴出来啊。
‘陆’ java 将返回list型 改为 返回数组型
两种方案：
第一种：（推荐使用这种）
只要修改返回类型，并把
return tmplist改成return tmplist.totoArray();就行了 取出的是Object数组，需要强制转换成HashMap；
//返回值是数组
public Object[] quyListBySqlAndParams(String querystr, List params,int dno) throws SQLException {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rst = null;
ResultSetMetaData rsmd = null;
List tmplist=new ArrayList();
try{
conn = myDataUtil.getConnection(dno);
pstmt = conn.prepareStatement(querystr);
//参数赋值
for(int i=0;i<params.size();i++){
String param = params.get(i)==null?"":params.get(i).toString().trim();
pstmt.setString(i+1,param);
}
rst = pstmt.executeQuery();
rsmd = rst.getMetaData();
while (rst.next()) {
Map tmpmap = new HashMap();
for ( int i = 1; i <= rsmd.getColumnCount(); i++ ){
tmpmap.put(rsmd.getColumnName(i), rst.getObject(i));
}
tmplist.add(tmpmap);
}
}catch(Exception e){
System.out.println("pubgetstr"+e.toString()+querystr);
}finally{
myDataUtil.free(rst,pstmt,conn);
//这里调用toArray()方法返回数组
return tmplist.toArray();
}
}
。
方案二：
原理就是将结果集的游标定位到最后一行，然后通过返回行号确定记录数，从而确定数组的长度。然后再将游标回退到beforefirst
但是一定要注意 这么做有个地方要考虑， 默认的ResultSet类型是TYPE_FORWARD_ONLY，只向前的游标，不允许指针回退;在定义时要将默认的ResultSet类型里的TYPE_FORWARD_ONLY改成ResultSet.TYPE_SCROLL_INSENSITIVE，把你那句改成这个
pstmt = conn.prepareStatement(querystr, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
//返回数组
public Object[] quyListBySqlAndParams(String querystr, List params,int dno) throws SQLException {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rst = null;
ResultSetMetaData rsmd = null;
Object[] tmpAarry;
try{
conn = myDataUtil.getConnection(dno);
//注意 这里做了修改 pstmt=conn.prepareStatement(querystr,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
//参数赋值
for(int i=0;i<params.size();i++){
String param = params.get(i)==null?"":params.get(i).toString().trim();
pstmt.setString(i+1,param);
}
rst = pstmt.executeQuery();
rsmd = rst.getMetaData();
// 这里做了修改
rst.last();
int count = rst.getRow();
tmpAarry = new Object[count];
rst.beforeFirst();
while (rst.next()) {
Map tmpmap = new HashMap();
int j = 0;
for ( int i = 1; i <= rsmd.getColumnCount(); i++ ){
tmpmap.put(rsmd.getColumnName(i), rst.getObject(i));
}
tmpAarry[j]=tmpmap;
j++;
}
}catch(Exception e){
System.out.println("pubgetstr"+e.toString()+querystr);
}finally{
myDataUtil.free(rst,pstmt,conn);
// 返回的是个数组
return tmpAarry;
}
}
好了，这两种方法的结构是一样的，看是你也看到了，自己写有多麻烦，还要考虑很多意想不到的问题，比如那个滚动结果集。所以能用java api中提供的最好用，那都是经得住考验的，而且方便的很。
‘柒’ java泛型方法可以返回 List<T> 吗
可以！！返回值必须是你定义的类型包含的泛型也必须一样
‘捌’ java中如何返回多个list
方法一、将多个List封装到一个JavaBean内：
private static void show1() {
StringEQTest.ListArr listArr = new StringEQTest.ListArr();
List<String> names = listArr.names;
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
List<Integer> ages = listArr.ages;
for (int i = 0; i < ages.size(); i++) {
System.out.println(ages.get(i));
}
}
public static class ListArr {
List<String> names = new ArrayList<String>();
List<Integer> ages = new ArrayList<Integer>();
public ListArr() {
names.add("names1");
names.add("names2");
names.add("names3");
ages.add(50);
ages.add(40);
ages.add(30);
ages.add(88);
}
public List<String> getNames() {
return names;
}
public void setNames(List<String> names) {
this.names = names;
}
public List<Integer> getAges() {
return ages;
}
public void setAges(List<Integer> ages) {
this.ages = ages;
}
}
结果：
names1
names2
names3
50
40
30
88
-------------------------------------------------------------------------------
方法二、将List包装到Map集合内，取出的时候需要进行类型转换
private static void show2() {
Map<String, Object> lists = getLists();
List<String> names = (List<String>) lists.get("names");
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
List<Integer> ages = (List<Integer>) lists.get("ages");
for (int i = 0; i < ages.size(); i++) {
System.out.println(ages.get(i));
}
}
public static Map<String, Object> getLists() {
List<String> names = new ArrayList<String>();
List<Integer> ages = new ArrayList<Integer>();
names.add("names1");
names.add("names2");
names.add("names3");
ages.add(50);
ages.add(40);
ages.add(30);
ages.add(88);
Map<String, Object> map = new HashMap<String, Object>();
map.put("names", names);
map.put("ages", ages);
return map;
}
结果：
names1
names2
names3
50
40
30
88
‘玖’ java中的executeQuery方法返回List集合和resultSet哪个更好
Table保存的什么类的内容，就返回一个 List<T>，方便调用者使用；List<HashMap>不是个好的选择。
一个人写着玩，随便了。