小编Rae*_*ald的帖子

当实现一个不可变类，该类具有由构造函数给定值初始化的聚合Collection时，构造函数必须制作该构造函数的防御性副本Collection，以防止调用者随后改变聚合。

在 Java 10 之前，这会产生如下代码：

class Thing\n{\n   private final List<Widget> widgets;\n\n   public Thing(List<Widget> widgets) {\n      this.widgets = Collections.unmodifiableList\xe2\x80\x8b(new ArrayList<>(widgets));\n   }\n\n   public List<Widget> getWidgets() {\n      return widgets;\n   }\n}\n

添加了 Java 10List.copyOf()和朋友，它们创建给定的不可修改的副本Collection. 这表明对于 Java 10+，我们可以编写如下代码：

class Thing\n{\n   private final List<Widget> widgets;\n\n   public Thing(List<Widget> widgets) {\n      this.widgets = List.copyOf(widgets);\n   }\n\n   public List<Widget> getWidgets() {\n      return widgets;\n   }\n}\n

我对么？

我想写一个可以用来初始化Map的方法.首裁:

Map map(Object ... o) {for (int i = 0; i < o.length; i+=2){result.put(o[i], o[i+1])}}

简单,但不是类型安全的.使用泛型,可能是这样的:

<TKey, TValue> HashMap<TKey, TValue> map(TKey ... keys, TValue ... values) 

但是不支持该语法.所以最终我来到这个:

public static <TKey, TValue, TMap extends Map<? super TKey, ? super TValue>> TMap map(TMap map, Pair<? extends TKey, ? extends TValue> ... pairs) {
    for (Pair<? extends TKey, ? extends TValue> pair: pairs) {
        map.put(pair.getKey(), pair.getValue());
    }
    return map;
}

public static <TKey, TValue> HashMap<? super TKey, ? super TValue> map(Pair<? extends TKey, …

通过运行测试程序和查看源代码,很明显,由Sun实现的方法不会简单地为指定的线程产生时间,但实际上它首先尝试在线程对象上获取监视器.具体而言,该方法实现为"同步".

请注意,wait和notify方法也需要监视器,但与join不同,调用者有责任在进行调用之前获取监视器,文档清楚地说明了这一点.Javadocs中没有记录连接取决于监视器的事实,尽管可能很自然地做出推断.

文档是否足够清晰？

此外,如果线程由于某种原因无法获取监视器,它将挂起,也许永远.在等待监视器时,线程不可中断,并且不会抛出InterruptedException,如文档中所述.另一方面,除了编程错误的情况之外,不清楚为什么线程无法获得监视器.

担心监视器争用是否合理？

最后,使超时操作依赖于获取监视器似乎是不合适的,除非可以保证获取监视器的任务本身会超时.

是否依赖于监视器的join()合理实现？甚至可以以任何其他方式实现它吗？

下面的示例是关于类的依赖注入Worker吗？该Worker班没有获得ITool从属性setter或构造函数实例,而是被从容器中取出呢？

public MainClass {

    static void Main(string[] args) {
        ITool someTool = new Tool();
        MyContainer.Register<ITool>(someTool);
    }
}

public class MyContainer {

    private WindsorContainer container;

    public MyContainer() {
        container = new WindsorContainer();
    }

    public static T Resolve<T>() {
        return container.Resolve<T>();
    }

    public static void Register<T>(object instance) {
        container.Kernel.AddComponentInstance(typeof(T).ToString(), typeof(T), instance);
    }
}

public class Worker {

    public DoSomeWork() {
        ITool tool = MyContainer.Resolve<ITool>();
        tool.DoTheWork();
    } 
}

此代码是否会导致内存泄漏:

int main(){

   int * a = new int[10];
   int * b  = new int[10];
   for(int i = 0 ; i < 10; i++)
   {
       a[i] = 1;
       b[i] = 1;
   }

   for(int i = 0 ; i < 10; i++)
   {
       a[i] = b[i]; //each a[i] is allocated 4 bytes on heap
                    //when we copy b[i] into a[i] do we loose 
                    //the reference to a[i] (hence a leak), 
                    //and replace that reference
                    //with a reference to a new value? …

自动装箱和拆箱实际上是运营商重载的奇特术语吗？我们说什么会发生什么Integer i = 10;？

我收到一个错误"无法找到符号方法添加(java.util.Date)",虽然我传递的是它被声明为Date.我错过了什么？

import java.util.*;
import java.text.SimpleDateFormat;
import java.text.*;


class Entry {
    Date date;

    Entry(Date aDate) {
        date = aDate;
    }
}

public class td {
    public static void main(String[] args) { 

        List<Entry> entries = new ArrayList<Entry>();

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date aDate = df.parse("2011-02-27"); // Date aDate = new Date() also fails

        entries.add(aDate);

        System.out.println(entries.get(0));
    }
}

问:我需要对以下代码的输出进行详细说明...使用runnable接口创建的线程和通过扩展线程类直接创建的线程有什么区别... ???

Q1:

public class BalanceChecker1{
    public static void main(String [] args) {
        RunnableClass runnableClass=new RunnableClass();
        new Thread(runnableClass).start();
        new Thread(runnableClass).start();
    }
}

class RunnableClass implements Runnable{
    Bean bean=new Bean();
    public void run(){
        synchronized(bean){
            bean.incBalance();
        }
    }
}

class Bean{
    private int balance=0;
    public void incBalance(){
        balance++;
        System.out.println(" The thread name "+Thread.currentThread().getName());
        System.out.println(" The balance is "+balance);
    }
}

OUTPUT:

 The thread name Thread-0
 The balance is 1
 The thread name Thread-1
 The balance is 2

Q2:

public class BalanceChecker1{
    public …

LinkedList上的帖子说:

LinkedList允许恒定时间插入或删除,但仅允许元素的顺序访问.换句话说,you can walk the list forwards or backwards, but grabbing an element in the middle需要时间与列表的大小成比例.

我不明白什么才有资格抓住中间的元素？

在下面的代码中,假设arrL是一个包含50个elemnet的LinkedList,当计数器j达到20时,程序执行arrL.get(20)..这是否意味着程序正在抓取中间的元素？同样在下面的程序我只是走向前面的列表,不是吗？

    for(int j=0;j<arrL.size();++j){
        arrL.get(j);
    }

我必须为WebPageData编写一个名为getWordsInString()的公共类方法.该方法采用一个名为text的参数,该参数应为String类型.getWordsInString()的目的是返回一个由文本引用的字符串中的distict词组成的集合.

首先使用您在Javadoc中找到的String类的方法,该类将根据字符串参数的值将任何字符串切割为多个部分.使用此方法将文本引用的字符串拆分为单词数组,并将此数组分配给名为wordArray的局部变量.该方法应声明一个能够引用一组字符串的局部变量,并为其分配一个合适类的空实例.接下来迭代wordArray并将其元素添加到新创建的集合中,最后返回应该包含文本引用的字符串中的不同单词的集合.

import java.util.*;

public class WebPageData {

private Set<String> wordSet;
private Set<String> url;

public Set<String> getUrl() {
    return url;
}

public Set<String> getWordSet() {
    return wordSet;
}

public static String getWordsInString(text) {
    return test;



public String[] split(String regex) {

            private String[] wordArray;

for (String eachText : numSet) {
    hashSet.add(text);
    ) 
   }

我正在努力解决这个问题,请帮忙吗？