Jsf 在按字段分组的页面上显示列表_Jsf

Jsf 在按字段分组的页面上显示列表

jsf

Jsf 在按字段分组的页面上显示列表,jsf,Jsf,我如何显示/呈现一些数据，如（制造商、颜色、类型），类似于此： List<Car> list = new ArrayList<>(); list.add(new Car("ford", "red", "focus")); list.add(new Car("opel", "red", "astra")); list.add(new Car("opel", "blue", "astra")); list.add(new Car("

我如何显示/呈现一些数据，如（制造商、颜色、类型），类似于此：

List<Car> list = new ArrayList<>();          
list.add(new Car("ford", "red", "focus"));    
list.add(new Car("opel", "red", "astra"));    
list.add(new Car("opel", "blue", "astra"));    
list.add(new Car("toyota", "red", "camry"));    
list.add(new Car("honda", "blue", "civic"));    
list.add(new Car("BMW", "green", "3"));

我需要更详细的解释。我不知道数据库中会出现什么颜色。它们是未知的，并且基于用户输入，并且它们的属性没有定义。这只是一个例子

更新

class Car {

private String name;
private String color;
private String model;


public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getModel() {
    return model;
}

public void setModel(String model) {
    this.model = model;
}

public String getColor() {
    return color;
}

public void setColor(String color) {
    this.color = color;
}
}

我的看法是：

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
  xmlns:h="http://xmlns.jcp.org/jsf/html"
  xmlns:ui="http://xmlns.jcp.org/jsf/facelets">
<h:head>
    <title>Facelet Title</title>
</h:head>
<h:body>
    Hello from Facelets
    <br/>
    <br/>
    <br/>
    <ui:repeat value="#{carBean.groups}" var="entry">
        <h:outputText value ="#{entry}"/>

        <br/>
        <ui:repeat value="asdasdas" var="second">
            #{second} <br/>
            <br/>
        </ui:repeat>


    </ui:repeat>

    <ui:repeat value="#{carBean.carsGroupedByColor.entrySet().toArray()}" var="entry">
        <div>
            Color: #{entry.key}
            <br />
            <ui:repeat value="#{entry.value}" var="car">
                Car name: #{car}
                <br />
            </ui:repeat>
        </div>
    </ui:repeat>



</h:body>
</html>


Facelet标题
Facelets的你好








#{second}



颜色：#{entry.key}


汽车名称：#{Car}

我的豆豆：

@Named
@ViewScoped
public class CarBean implements Serializable {

private Map<String, List<Car>> carsGroupedByColor;
private List<String> groups;
private List<Car> temp;
private List<Car> carsByColor;

@PostConstruct
public void init() {

    List<Car> list = new ArrayList<>();
    Car car = new Car();
    car.setColor("red");
    car.setModel("camry");
    car.setName("redcar1");
    list.add(car);
    Car car1 = new Car();
    car1.setColor("bue");
    car1.setModel("golf");
    car1.setName("bluecar1");
    list.add(car1);
    Car car2 = new Car();
    car2.setColor("red");
    car2.setModel("astra");
    car2.setName("redcar2");
    list.add(car2);

    System.out.println(list);


    groups = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        //         System.out.println(list.get(i).getName());
        //         System.out.println(list.get(i).getColor());
        //        System.out.println(list.get(i).getModel());
        groups.add(list.get(i).getColor());

    }

    Set<String> set = new HashSet<>(groups);
    groups.clear();
    groups.addAll(set);
    carsGroupedByColor = new LinkedHashMap<>();

    Car carx;

    for (int i = 0; i < groups.size(); i++) {
        temp = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {

            if (groups.get(i).equals(list.get(j).getColor())) {
                carx = new Car();
                carx.setColor(list.get(j).getColor());
                carx.setName(list.get(j).getName());
                carx.setModel(list.get(j).getModel());

                System.out.println("Color is " + groups.get(i) + "=" + list.get(j).getColor());
                System.out.println(list.get(j).getName());
                temp.add(carx);
            }
        }
        System.out.println(temp);
        carsGroupedByColor.put(groups.get(i), temp);
        System.out.println("carsGroupedByColorcars is " + carsGroupedByColor.get(groups.get(i)));

        System.out.println("temp is clear: " + temp);

    }

    for (int i = 0; i < groups.size(); i++) {

        System.out.println(groups.get(i) + "   " + carsGroupedByColor.get(groups.get(i)));



    }
}

public Map<String, List<Car>> getCarsGroupedByColor() {
    return carsGroupedByColor;
}

public void setCarsGroupedByColor(Map<String, List<Car>> carsGroupedByColor) {
    this.carsGroupedByColor = carsGroupedByColor;
}

public List<String> getGroups() {
    return groups;
}

public void setGroups(List<String> groups) {
    this.groups = groups;
}
}

@Named
@视域
公共类CarBean实现了可序列化{
私人地图车按颜色分组；
私人名单组；
私人名单；
私人列表carsByColor；
@施工后
公共void init（）{
列表=新的ArrayList（）；
汽车=新车（）；
汽车颜色（“红色”）；
汽车.setModel（“凯美瑞”）；
car.setName（“redcar1”）；
列表。添加（car）；
Car car1=新车（）；
car1.setColor（“bue”）；
car1.setModel（“高尔夫”）；
car1.集合名（“bluecar1”）；
列表。添加（car1）；
Car car2=新车（）；
car2.设置颜色（“红色”）；
car2.setModel（“astra”）；
car2.集合名（“redcar2”）；
列表。添加（car2）；
系统输出打印项次（列表）；
groups=newarraylist（）；
对于（int i=0；i

HashMap cars=newhashmap（）；
列表红色=新的ArrayList（）；
List blue=新的ArrayList（）；
绿色列表=新的ArrayList（）；
红色。添加（新车（“福特”、“红色”、“福克斯”）；
红色。添加（新车（“欧宝”、“红色”、“阿斯特拉”）；
蓝色。添加（新车（“欧宝”、“蓝色”、“阿斯特拉”）；
红色。添加（新车（“丰田”、“红色”、“凯美瑞”）；
蓝色。添加（新车（“本田”、“蓝色”、“思域”）；
绿色。添加（新车（“宝马”、“绿色”、“3”））；
汽车。放（“红色”，红色）；
汽车。放（“蓝色”，蓝色）；
汽车。放（“绿色”，绿色）；
//现在很容易按颜色打印；）
System.out.println（“[红色]”）；
对于（汽车：（列表）汽车。获取（“红色”））
System.out.println（car.getColor（））；
//等

HashMap cars=newhashmap（）；
列表红色=新的ArrayList（）；
List blue=新的ArrayList（）；
绿色列表=新的ArrayList（）；
红色。添加（新车（“福特”、“红色”、“福克斯”）；
红色。添加（新车（“欧宝”、“红色”、“阿斯特拉”）；
蓝色。添加（新车（“欧宝”、“蓝色”、“阿斯特拉”）；
红色。添加（新车（“丰田”、“红色”、“凯美瑞”）；
蓝色。添加（新车（“本田”、“蓝色”、“思域”）；
绿色。添加（新车（“宝马”、“绿色”、“3”））；
汽车。放（“红色”，红色）；
汽车。放（“蓝色”，蓝色）；
汽车。放（“绿色”，绿色）；
//现在很容易按颜色打印；）
System.out.println（“[红色]”）；
对于（汽车：（列表）汽车。获取（“红色”））
System.out.println（car.getColor（））；
//等

您可以拥有一张地图
并迭代主列表中的所有汽车
，以便在地图中相应地分配汽车（我假设汽车#颜色
是一个字符串
，否则使用正确的类型作为地图键）
Java代码：
@ManagedBean
@ViewScoped
public class CarBean {

    private Map<String, List<Car>> carsGroupedByColor;

    @PostConstruct
    public void init() {
        List<Car> allCars = ...; //this can be replaced to retrieve the list the way you want/need
        Map<String, List<Car>> carsGroupedByColor = new LinkedHashMap<String, List<Car>>();
        for (Car car : allCars) {
            List<Car> carsByColor = carsGroupedByColor.get(car.getColor());
            if (carsByColor == null) {
                carsByColor = new ArrayList<Car>();
            }
            carsByColor.add(car);
        }
    }

    public Map<String, List<Car>> getCarsGroupedByColor() {
        return carsGroupedByColor;
    }
}

@ManagedBean
@视域
公共级卡宾{
私人地图车按颜色分组；
@施工后
公共void init（）{
List allCars=…；//可以替换此选项以按您想要/需要的方式检索列表
Map carsGroupedByColor=新建LinkedHashMap（）；
用于（汽车：所有汽车）{
List carsByColor=carsGroupedByColor.get（car.getColor（））；
if（carsByColor==null）{
carsByColor=newarraylist（）；
}
carsByColor.add（car）；
}
}
公共地图getCarsGroupedByColor（）{
返回carsGroupedByColor；
}
}

Facelets代码：

颜色：#{entry.key}


汽车名称：#{Car.name}


您可以拥有一张地图
并迭代主列表中的所有汽车
，以便在地图中相应地分配汽车（我假设汽车#颜色
是一个字符串
，否则使用正确的类型作为地图键）
Java代码：
@ManagedBean
@ViewScoped
public class CarBean {

    private Map<String, List<Car>> carsGroupedByColor;

    @PostConstruct
    public void init() {
        List<Car> allCars = ...; //this can be replaced to retrieve the list the way you want/need
        Map<String, List<Car>> carsGroupedByColor = new LinkedHashMap<String, List<Car>>();
        for (Car car : allCars) {
            List<Car> carsByColor = carsGroupedByColor.get(car.getColor());
            if (carsByColor == null) {
                carsByColor = new ArrayList<Car>();
            }
            carsByColor.add(car);
        }
    }

    public Map<String, List<Car>> getCarsGroupedByColor() {
        return carsGroupedByColor;
    }
}

@ManagedBean
@视域
公共级卡宾{
私人地图车按颜色分组；
@施工后
公共void init（）{
List allCars=…；//可以替换此选项以按您想要/需要的方式检索列表
Map carsGroupedByColor=新建LinkedHashMap(
@ManagedBean
@ViewScoped
public class CarBean {

    private Map<String, List<Car>> carsGroupedByColor;

    @PostConstruct
    public void init() {
        List<Car> allCars = ...; //this can be replaced to retrieve the list the way you want/need
        Map<String, List<Car>> carsGroupedByColor = new LinkedHashMap<String, List<Car>>();
        for (Car car : allCars) {
            List<Car> carsByColor = carsGroupedByColor.get(car.getColor());
            if (carsByColor == null) {
                carsByColor = new ArrayList<Car>();
            }
            carsByColor.add(car);
        }
    }

    public Map<String, List<Car>> getCarsGroupedByColor() {
        return carsGroupedByColor;
    }
}