小编Nat*_*hes的帖子

假设我有一个数组

public static final String[] fooArray ={ Foo.a, Foo.b, Foo.c };

其中Foo.ab和c是静态最终字符串.

我仍然可以做这样的事情fooArray[0] = "taco";,并最终{ taco, Foo.b, Foo.c }为fooArray的内容是什么？

如果是这样,是否会将数组设为私有,并使用getter来生成数组的副本以Arrays.copyOf解决此问题？

我正在创建一个类,它的私有成员之一是另一个类的对象.当我尝试调用已在我的公共实例方法中创建的类的公共实例方法时,我得到一个NullPointerException.

我测试了它,当我从构造函数调用find函数时,它工作正常,但是当我从下一个随机函数调用find函数时,它给了我异常.怎么了？

public class Percolation
{
   private WeightedQuickUnionUF uf;
   private boolean sites[][];

   public Percolation(int N)//constructor
   {
       sites = new boolean[N][N];
       int arraySize = N * N;
       WeightedQuickUnionUF uf = new WeightedQuickUnionUF(arraySize);
       System.out.println("we found the first node at " + uf.find(31));
   }

   public void trialQuickFind()
   {
       System.out.println("we found the first node at " + uf.find(31));
   }
}   

正如文件所说

睡觉时线程不释放它所持有的锁

但是我的代码片段演示了它确实释放了锁

public class SynchronizationTest {

    public static void main(String[] args) {
        Common c = new Common();
        new PersonONE(c);
        new PersonTWO(c);
    }
}

class Common {
    private String message = "This is shared message";
    public String getMessage() {
        return message;
    }
}

class PersonONE extends Thread {
    private Common c;
    public PersonONE(Common c) {
        this.c = c;
        start();
    }
    @Override
    public void run() {
        synchronized (c.getClass()) {
            for (int i = 0; i < 5; i++) { …

我的意思是,为什么存在defacto不可变对象？为什么我们不只是使用最终的静态修饰符？关于String,Java使它变得不可变的重要性是什么？

我只需要用java线程做一个竞争条件的例子,我写了这个代码,但我不确定它是否有竞争条件.

有人可以告诉我下面的代码是否有竞争条件,还有我如何改进或简化？

(抱歉英文不好)

public class RaceCondition extends Thread{

static int count=0;   //the variable where the race condition need to happen
static int contador1 = 0;    //variables to count
static int contador2 = 0;


static Thread t1 = new Thread(new Runnable() {
    public void run(){

        while(contador1!=20){
        count ++;
        System.out.print(count + " ");
        contador1++;

        }
    }
     });

static Thread t2 = new Thread(new Runnable() {
    public void run(){
        while(contador2!=20){

        int k = 5;
        count += 5*k;
        System.out.print(count + " ");
        contador2 ++; …

为什么这段代码不起作用？

println getValueFromMap(new HashMap().put("a","aaaaa"))
//Its calling Method
def String getValueFromMap(Map<String,String> mapObject){
    return mapObject.get("a")
}

而以下代码正在工作。

Map<String,String> fooMap=new HashMap()
fooMap.put("b","bbbbb")
println getValueFromMap(fooMap)
//Its calling Method
def String getValueFromMap(Map<String,String> mapObject){
    return mapObject.get("b")
}

请解释。

请考虑以下代码

 String unformattedXml ="<root>  <?xml version=\"1.0\" encoding=\"UTF-8\"?> <SOAP-ENV:Envelope xmlns:SOAP-ENV=";        

 unformattedXml = unformattedXml.replaceAll("<?xml version=\"1.0\" encoding=\"UTF-8\"?>","");

 System.out.println(unformattedXml);

输出是:

<root>  <?xml version="1.0" encoding="UTF-8"?> <SOAP-ENV:Envelope xmlns:SOAP-ENV=

正如你必须已经理解的那样,我想从字符串中删除xml标签,但不知何故,该replaceAll功能并没有帮助我.

有什么建议？？

谢谢!

我正在学习Java中的内部类,但我编写这段代码,当我编译它时,我得到了这个错误: Error:(84, 23) java: non-static variable this cannot be referenced from a static context.

    public class Main {

    class Outer {
        private String string;

        Outer(String s) {
            this.string = s;
        }

        public Inner inner() {
            return new Inner();
        }

        class Inner {
            @Override
            public String toString() {
                return string;
            }
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer("yang");
      //  System.out.println(outer.inner().toString());
    }
}

我已将内部类更新为此,它可以工作.

public class Main {

    static class Outer {
        private …

我希望非静态块总是在创建对象时执行.但在下面的示例中,我调用了静态方法,但执行了非静态块.我没有创建任何对象,为什么非静态块执行？

class Example {
  static void Mark() {
    System.out.println("Mark method");
    {
      System.out.println("Hello");
    }
  }
}   

public class StaticObject {
  public static void main(String[] args) {
    Example.Mark();
  }
}

结果:

Mark method
Hello