标签: arraylist

我们如何在ArrayList中获取最后添加的元素.我发现这解释了如何获取最后一个元素,但最后添加的元素总是最后一个元素？

我有一个关于保存自定义对象的arraylist的问题.我有一个名为notitie的课程:

public class Notitie implements Serializable{

private String titel = "";
private String type = "";
private String datum = "";

public void setTitel (String titel){
    this.titel = titel;
}
public String getTitel(){
    return titel;
}
public void setType (String type){
    this.type = type;
}
public String getType(){
    return type;
}
public void setDatum (String datum){
    this.datum = datum;
}
public String getDatum(){
    return datum;
}
}

我创建了一些Notitie的对象,并将它们添加到我的名为notities的arraylist中

ArrayList<Notitie> notities = new ArrayList<Notitie>();

Notitie notitie1 = new Notitie();
notitie1.setTitel("Meting");
notitie1.setType("Watermeting"); …

在Java中,我被要求在单链表中存储整数值,然后打印存储在列表中的元素.这是我想出的:

int max = 10;
List<Integer> list = new ArrayList<Integer>();

for (int num = 0; i < max; i++){
     list.add(num);
}
System.out.print(list);

我想知道,ArrayList和单链表一样吗？我想确保我正确地回答了这个问题.这有意义吗？谢谢!

我有一个字符串列表:

List<String> terms = ["Coding is great", "Search Engines are great", "Google is a nice search engine"]

如何获得列表中每个单词的频率:例如{Coding:1, Search:2, Engines:1, engine:1, ....}

这是我的代码:

    Map<String, Integer> wordFreqMap = new HashMap<>(); 
    for (String contextTerm : term.getContexTerms()  ) 
                {
                    String[] wordsArr = contextTerm.split(" ");
                    for (String  word : wordsArr) 
                    {
                        Integer freq = wordFreqMap.get(word); //this line is getting reset every time I goto a new COntexTerm
                        freq = (freq == null) ? 1: ++freq;
                        wordFreqMap.put(word, freq);
                    }
                }

在ArrayList中增加Integer的最简洁方法是什么？

ArrayList<Integer> ints = new ArrayList<>();
ints.add(5);
ints.add(9);

增加最后一个元素的最简洁方法是什么？

ints.set(ints.size() - 1, ints.get(ints.size() - 1) + 1); 对我来说似乎很难看.

我知道这是一件小事,但我想问这个问题.假设我有一个返回对象ArrayList的get方法.首先,我们必须返回它的副本吗？如果是这样,它是否必须是ArrayList的深层副本？当内部的对象是不可变的时,我们还需要做一个深层复制吗？如果我们使用这种类型的构造函数

ArrayList<T> arr = new ArrayList<>(collection);

然后是复制的数组元素还是仍指向旧值？谢谢

ArrayList<Integer> a =new ArrayList<Integer>();
ArrayList<ArrayList<Integer>> j =new ArrayList<ArrayList<Integer>>();

a.add(1);
a.add(2);
a.add(3);

for(int c=0; c<10; c++){
    j.add(a);
}
j.get(3).add(1);
System.out.println(j);

有谁知道为什么这个代码为j的每个元素添加1而不是只有第三个元素,我该怎么做才能解决这个问题？

我需要分离和计算arraylist中的多少个值是相同的,并根据出现的次数打印它们.

我有一个名为数字的arraylist:

 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

我创建了一个方法来分隔每个值并将其保存到一个新数组.

public static ArrayList<Integer> myNumbers(int z) {

    ArrayList<Integer> digits = new ArrayList<Integer>();
    String number = String.valueOf(z);
    for (int a = 0; a < number.length(); a++) {
        int j = Character.digit(number.charAt(a), 10);
        digits.add(j);
    }
    return digits;

}

在此之后,我有一个名为数字的新数组.我在这个数组上使用sort

Collections.sort(numbers);

我的ArrayList看起来像这样:

[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, …

这两个代码有什么区别:

Arraylist<Integer> listofIntegers = new Arraylist<Integer>();
listofIntegers.add(666);
System.out.println("First Element of listofIntegers = " + listofIntegers.get(0));

和

Arraylist<Integer> listofIntegers = new Arraylist<Integer>();
listofIntegers.add(Integer.ValueOf(666));
System.out.println("First Element of listofIntegers = " + listofIntegers.get(0));

它们都具有相同的输出.

谢谢.

我如何通过衬衫尺寸组织重新安排我的阵列:

[
  { shirt_id: 1, size: "small" },
  { shirt_id: 1, size: "medium" },
  { shirt_id: 1, size: "large" },
  { shirt_id: 2, size: "medium" },
  { shirt_id: 3, size: "large" }
];

期望的输出:

[
  [1, { size: "small" }, { size: "medium" }, { size: "large" }],
  [2, { size: "medium" }],
  [3, { size: "large" }]
];