小编Pio*_*ski的帖子

我正在探索我的 Android 项目的构建扫描，我发现该任务com.android.build.gradle.tasks.PackageApplication不可缓存，原因如下：Not cacheable: Task output caching not enabled。

是否可以使该任务可缓存，例如通过在gradle.properties文件中设置一些标志？

我正在使用 Android Gradle 插件 3.4.2

我正在和Mockito一起创建一个测试.在测试中,我正在创建一个类型的对象ContentValues.当我运行此测试时,我收到错误:

java.lang.RuntimeException: Method put in android.content.ContentValues not mocked.

这是最小的代码:

import android.content.ContentValues;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class MyClassTest {
    @Test
    public void test1() {
        ContentValues cv = new ContentValues();
        cv.put("key", "value");
    }
}

怎么做才能避免这个错误？

我有一段代码返回一个字段的值,但也初始化它:

public Observable<Integer> asObservable() {
    if (subject == null) {
        subject = BehaviorSubject.createDefault(0);
    }
    return subject;
}

我正在尝试使用Optional类来避免if声明:

public Observable<Integer> asObservableWithOptional() {
    Optional.ofNullable(subject)
            .executeIfAbsent(() -> BehaviorSubject.createDefault(0));
    return subject;
}

Hovewer我对这段代码仍然不满意.有没有办法只用一个语句把这个方法变成一个？类似于以下的东西将无法工作,因为subject在调用ofNullable工厂方法期间尚未初始化:

    return Optional.ofNullable(subject)
            .executeIfAbsent(() -> BehaviorSubject.createDefault(0))
            .get();

注意:我没有使用原始Java8 API,而是使用此API的aNNiMON端口https://github.com/aNNiMON/Lightweight-Stream-API.

Android 上的传统EditText支持android:selectAllOnFocus属性，这会导致当用户单击 时选择其内容EditText。

在 Jetpack Compose 中使用时如何实现此行为androidx.compose.material.TextField？

我想用一些指定的标签报告哨兵事件，但是我不想在以后的事件中包含这个标签。

使用以下代码，我添加了一个标签和报告事件：

Sentry.getContext().addTag("my_tag", "yes");
Sentry.capture("event happened");

然后，过了一会儿，另一个事件发生了：

Sentry.capture("another event happened"); // tag is included, but I don't want it

我试过删除标签，Sentry.clearContext()但它会清除所有信息，包括面包屑。

我也尝试过，Sentry.getContext().getTags().remove("my_tag");但是由于标签保留在 中UnmodifiableMap，因此此操作只会引发异常。

我一直认为，在使用Dagger2时，我们应该使用@Reusable范围，而不是@Singleton如果我们不需要保证总是获得相同的实例，因为@Singleton使用了双重检查，这既昂贵又缓慢。

但是，我进行了简单的性能测试，结果如下：

Reusable  4474 ms
Singleton 3603 ms

这是代码：

@Singleton
@Component
interface AppComponent {

    fun getReusable(): ReusableFoo

    fun getSingleton(): SingletonFoo
}

@Reusable
class ReusableFoo @Inject constructor()

@Singleton
class SingletonFoo @Inject constructor()

class TestClass {
    @Test
    fun test() {
        val component = DaggerAppComponent.builder().build()
        measure {
            component.getReusable()
        }
        measure {
            component.getSingleton()
        }
    }

    private fun measure(block: () -> Unit) {
        val start = System.currentTimeMillis()
        (0..1000000000).forEach { block() }
        println(System.currentTimeMillis() - start)
    }
}

在构造较重的类（我尝试过使用Retrofit）和带 …

我LinearLayout用三个相同的元素创建了一个简单的：

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <TextView
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Hello"/>

    <TextView
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Hello"/>

    <TextView
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Hello"/>
</LinearLayout>

现在我要介绍8dp每对元素之间的空间。

以下哪个解决方案被认为是更清洁的？

或者：

或者其他一些？

我有两个班:Age和Animal.

我认为构造函数Age应该被调用两次:

• 第一次来 Animal a = Animal(13);
• 第二次开启a.getAge();(因为Age temp(age);在函数定义中)

但是...输出main()是Age constructor!代替Age constructor!Age constructor!,所以看起来这个构造函数只被调用一次(我已经检查过它是在构造Animal对象时被调用的.).为什么？

这是我的代码:

class Age {
private:
    int value;
public:
    Age(int a) :value(a) { cout << "Age constructor!"; }
};

class Animal {
private:
    Age age;
public:
    Animal(int a) : age(a) {}
    Age getAge() const { Age temp(age); return temp; }
};

void main() {   
    Animal a = Animal(13);

    a.getAge(); …

请告诉我，如果我正在应用Tell，请不要在此示例中以正确的方式询问原则。

我有两个类，CalculationResults有一个函数calculateMe()，Data用于进行一些计算。重要的是它存储结果。

class Data {
private:
  int dataForCalculations;
public:
  void calculate(CalculationResults& calculationResults) {
    calculationResults.calculateMe(dataForCalculations);
  }
};

class CalculationResults {
private:
  int calculatedData;
public:
  void calculateMe(int dataForCalculations) {
    calculatedData = someCalculations(dataForCalculations);
  }
};

// somewhere else:
Data data;
CalculationResults calculationResults;
data.calculate(calculationResults);

这段代码的第一个版本（在应用Tell之前，不要问）没有使用Data::calculatefunction 但它有一个getterfor dataForCalculations，所以我在某处调用了calculationResults.calculateMe(data.getDataForCalculations()).

新版本更好吗？

在我的Fragment我有一个静态newInstance方法,它接受一些参数,把它们放入Bundle,Fragment用这个创建新的Bundle:

public static Fragment newInstance(final CommandWithNumber command) {
    final CallsFragment fragment = new CallsFragment();
    final Bundle args = new Bundle();
    args.putSerializable(SHOW_DETAILS_COMMAND, command);
    fragment.setArguments(args);
    return fragment;
}

有没有办法阻止new CallsFragment()在代码中的其他地方调用并强制开发人员使用newInstance方法？

当然,我不能CallsFragment私有,因为操作系统需要公开的.如果有人试图用构造函数创建一个实例,也许有办法显示警告？

我如何使用Java Optional API以更优雅的方式重写以下代码:

first == null || second == null ? null : first + second;

null如果两个变量中的任何一个是null或其他地方的总和,则代码应该返回.