//一维数组定义与输出
class  less02
{
public static void main(String[] args)
{
int stu[]=new int[]{1,2,3};   //方法一，在数据定义的时候[]里是没有值的，因为后面已经给数组的每个元素赋值，数组的长度范围已经确定？
//int stu[]={1,2,3};                 方法二
//int []stu=new int[]{1,2,3};  方法三
//int[] stu={1,2,3};                方法四
for(int i=0;i
System.out.println(stu[i]);
}
}
//二维数组定义与输出
class less02
{
public static void main(String args[])
{
//int [][] num=new int[][]{{1,2,3},{4,5,6}};     方法一
int [][] num={{1,2,3},{4,5,6}};                      //方法二
for (int i=0;i
{
for (int j=0;j
{
System.out.print(num[i][j]+" ");
}
System.out.println();
}
}
}

java  - 如何在Spring中定义List bean？
我正在使用Spring在我的应用程序中定义阶段。 配置为必要的类(此处称为Configurator)注入阶段。
现在我需要另一个班级的阶段列表，名为LoginBean.Configurator不提供访问他的阶段列表的权限。
我无法改变类Configurator。
我的想法：
定义一个名为Stages的新bean，并将其注入Configurator和LoginBean。我的这个想法的问题是我不知道如何转换这个属性：
...
...
...
成豆。
这样的东西不起作用：
任何人都可以帮我吗？
10个解决方案
266 votes
导入spring util命名空间。 然后您可以按如下方式定义列表bean：
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-2.5.xsd">
foo
bar
value-type是要使用的泛型类型，并且是可选的。 您还可以使用属性list-class指定列表实现类。
simonlord answered 2019-03-11T05:40:10Z
162 votes
这是一种方法：
stacker answered 2019-03-11T05:40:35Z
33 votes
另一种选择是使用JavaConfig。 假设所有阶段都已注册为spring beans，您只需：
@Autowired
private List stages;
和spring会自动将它们注入此列表中。 如果您需要保留订单(上层解决方案不这样做)，您可以这样做：
@Configuration
public class MyConfiguration {
@Autowired
private Stage1 stage1;
@Autowired
private Stage2 stage2;
@Bean
public List stages() {
return Lists.newArrayList(stage1, stage2);
}
}
保留顺序的另一个解决方案是在bean上使用@Order注释。 然后列表将包含按升序注释值排序的bean。
@Bean
@Order(1)
public Stage stage1() {
return new Stage1();
}
@Bean
@Order(2)
public Stage stage2() {
return new Stage2();
}
Jakub Kubrynski answered 2019-03-11T05:41:19Z
29 votes
class="com.somePackage.SomeClass">
在SomeClass中：
class SomeClass {
private List myList;
@Required
public void setMyList(List myList) {
this.myList = myList;
}
}
Koray Tugay answered 2019-03-11T05:41:46Z
8 votes
Stacker提出了一个很好的答案，我会更进一步使其更具动态性并使用Spring 3 EL Expression。
#{springDAOBean.getGenericListFoo()}
我试图找出如何使用util：list来实现这一点，但由于转换错误而无法使其工作。
haju answered 2019-03-11T05:42:19Z
4 votes
我想你可能在寻找。
您声明一个ListFactoryBean实例，提供要实例化为2252339368404714496元素作为其值的属性的列表，并为该bean提供id属性。 然后，每次在声明的id中使用ref或类似的其他bean声明时，都会实例化列表的新副本。 您还可以指定要使用的List类。
Stephen C answered 2019-03-11T05:42:54Z
1 votes
使用util命名空间，您将能够在应用程序上下文中将列表注册为bean。 然后，您可以重用该列表将其注入其他bean定义中。
Juan Perez answered 2019-03-11T05:43:21Z
1 votes
作为Jakub答案的补充，如果您打算使用JavaConfig，您也可以通过这种方式自动装配：
import com.google.common.collect.Lists;
import java.util.List;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
@Configuration
public class MyConfiguration {
@Bean
public List stages(final Stage1 stage1, final Stage2 stage2) {
return Lists.newArrayList(stage1, stage2);
}
}
Jose Alban answered 2019-03-11T05:43:48Z
0 votes
这是如何在Spring中的一些属性中注入set：
class="biz.bsoft.processing">
Slava Babin answered 2019-03-11T05:44:15Z
0 votes
之后定义那些bean(test1，test2):)
RaM PrabU answered 2019-03-11T05:44:41Z

本文实例讲述了Java定义泛型方法。分享给大家供大家参考，具体如下：
一 点睛
1 如果定义类、接口是没有使用类型形参，但定义方法时想自己定义类型形参，这也是可以的，JDK1.5还提供了泛型方法的支持。
2 泛型方法的语法格式为：
修饰符  返回值类型 方法名(形参列表)
{
//方法体...
}
3 泛型方法的方法签名比普通方法的方法签名多了类型形参声明，类型形参声明以尖括号括起来，多个类型形参之间以逗号(,)隔开，所有类型形参声明放在方法修饰符和方法返回值类型之间。
4 与类、接口中使用泛型参数不同的是，方法中的泛型参数无需显式传入实际类型参数，因为编译器根据实参推断类型形参的值。它通常推断出最直接的类型参数。
5 大时候都可以使用泛型方法来代替类型通配符。
6 泛型方法允许类型形参被用来表示方法的一个或多个参数之间的类型依赖关系，或者方法返回值与参数之间的类型依赖关系。如果没有这样的类型依赖关系，不应该使用泛型方法。
二 实战
import java.util.*;
public class GenericMethodTest
{
// 声明一个泛型方法，该泛型方法中带一个T类型形参，
static  void fromArrayToCollection(T[] a, Collection c)
{
for (T o : a)
{
c.add(o);
}
}
public static void main(String[] args)
{
Object[] oa = new Object[100];
Collection co = new ArrayList<>();
// 下面代码中T代表Object类型
fromArrayToCollection(oa, co);
String[] sa = new String[100];
Collection cs = new ArrayList<>();
// 下面代码中T代表String类型
fromArrayToCollection(sa, cs);
// 下面代码中T代表Object类型
fromArrayToCollection(sa, co);
Integer[] ia = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection cn = new ArrayList<>();
// 下面代码中T代表Number类型
fromArrayToCollection(ia, cn);
// 下面代码中T代表Number类型
fromArrayToCollection(fa, cn);
// 下面代码中T代表Number类型
fromArrayToCollection(na, cn);
// 下面代码中T代表Object类型
fromArrayToCollection(na, co);
// 下面代码中T代表String类型，但na是一个Number数组，
// 因为Number既不是String类型，
// 也不是它的子类，所以出现编译错误
//  fromArrayToCollection(na, cs);
}
}
三 错误用法
import java.util.*;
public class ErrorTest
{
// 声明一个泛型方法，该泛型方法中带一个T类型形参,两个参数类型必须一致
static  void test(Collection from, Collection to)
{
for (T ele : from)
{
to.add(ele);
}
}
public static void main(String[] args)
{
List as = new ArrayList<>();
List ao = new ArrayList<>();
// 下面代码将产生编译错误，传参类型不一致，编译器迷惑了
// test(as , ao);
}
}
四 正确用法
import java.util.*;
public class RightTest
{
// 声明一个泛型方法，该泛型方法中带一个T形参
static  void test(Collection extends T> from , Collection to)
{
for (T ele : from)
{
to.add(ele);
}
}
public static void main(String[] args)
{
List ao = new ArrayList<>();
List as = new ArrayList<>();
// 下面代码完全正常,因为前一个集合的元素类型是后一个集合元素类型的子类型
test(as , ao);
}
}
希望本文所述对大家java程序设计有所帮助。

关于有序和无序的定义：
有序：有序列表中的元素具有某种内在的关联，这种关联定义了列表之间的顺序
无序：无序列表中的元素按使用者所选择得任意方式排序
索引：索引列表为他的元素维护一段连续的数字索引值
有序列表：
List
HashTable
TreeMap
无序列表
HashMap
Set
测试代码：
package com.nps.base.xue.DataStructure.iteration;
import java.util.*;
/*
* @author XueWeiWei
* @date 2019/9/8 15:53
*/
public class TestOne {
public static void main(String[] args) {
/**
* 测试list
*/
List list = new ArrayList();
list.add(0,'D');
list.add(1,'A');
list.add(2,'1');
for (char i:list
) {
System.out.println(i);
}
System.out.println(list);
/**
* 测试list是否有序
*/
List list2 = new ArrayList();
list2.add(1);
list2.add(4);
list2.add(3);
for (Integer i:list2
) {
System.out.println(i);
}
System.out.println(list2);
/**
* 测试Map
*/
Map map = new TreeMap<>();
map.put(3,"lo");
map.put(1,'l');
map.put(2,2);
System.out.println("treeMap是有序的");
System.out.println(map);
/**
* 测试Set
*/
Set set = new HashSet();
set.add(69);
set.add(15);
set.add(1);
set.add(2);
System.out.println("set是无序的");
System.out.println(set);
}
}
测试结果：
D
A
1
[D, A, 1]
1
4
3
[1, 4, 3]
treeMap是有序的
{1=l, 2=2, 3=lo}
set是无序的
[1, 2, 69, 15]
Process finished with exit code 0
标签：set,java,序列表,list,System,add,println,out
来源： https://www.cnblogs.com/xww115/p/11487255.html