我有一个带有PageTransformer实现的ViewPager,它为ViewPager的下一页做了一些时髦的东西.我的实现看起来像这样:
class ZoomOutPageTransformer implements ViewPager.PageTransformer {
private static final float MIN_SCALE = 0.85f;
private static final float MIN_ALPHA = 0.5f;
@Override
public void transformPage(View view, float position) {
int pageWidth = view.getWidth();
if (position < -1) { // [-Infinity,-1)
// This page is way off-screen to the left.
view.setAlpha(0);
} else if (position <= 0) { // [-1,0]
// Use the default slide transition when moving to the left page
} else if (position < 1) { // (0,1]
do …我正在尝试使用ViewPager在Android中创建一个类似火炬的UI.
我看过这个库:https://github.com/kikoso/Swipeable-Cards但是我希望能够在我向右滑动时看到前一张卡片,因此喜欢ViewPager.
我正在寻找的具体UI细节是:
使用当前视图下方的下一个视图的轮廓堆叠图像.我已经能够通过ViewPager.PageTransformer接口实现视图的堆叠,但我无法获得寻呼机内部后续视图的堆栈轮廓 - 这个部分给它一个3d外观 - 就像在这里 - 卡堆叠在另一张卡片上 - http://i1.cdnds.net/14/38/300x522/friends-tinder-profiles-ross.jpg
这是我的pageTransform方法
public void transformPage(View view, float position) {
int pageWidth = view.getWidth();
if (position < -1) { // [-Infinity,-1)
// This page is way off-screen to the left.
view.setAlpha(0);
} else if (position <= 0) { // [-1,0]
// Use the default slide transition when moving to the left page
view.setAlpha(1);
view.setTranslationX(0);
view.setScaleX(1);
view.setScaleY(1);
view.setRotation(90*(position));
} else if (position < 1) …我正在阅读Java的Play框架,但没有太多的Java经验.有人可以解释一下
Promise<Double> promiseOfPIValue = computePIAsynchronously();
Promise<Result> promiseOfResult = promiseOfPIValue.map(
new Function<Double,Result>() {
public Result apply(Double pi) {
return ok("PI value computed: " + pi);
}
}
);
我知道他们正在创建一个promiseOfPiValue应该异步计算双重的承诺.然后,他们调用map那个他们传递一个新实例Function作为参数的promise实例,该实例实现了一个apply方法.
地图部分是我迷路的地方 - 地图方法如何运作？看起来它返回了一个新的类型的承诺Result,但是在实现中调用apply方法的逻辑是什么Function？
我正在尝试使用 rspec 3.0 测试 own_to 关联，但我不断遇到错误
NoMethodError：RSpec::Core 的未定义方法“belong_to”
it "should belong to a user" do
ride = Ride.new
user = User.new
user.rides << ride
expect(ride).to belong_to user
结尾
我在 rspec 3.0 的文档中找不到任何用于测试高级关联的内容。请帮助！
我正在尝试Android的新TabLayout类,在我的ActionBar下面添加两个标签.每个选项卡将托管不同的片段.
此外,我不希望能够在我的两个标签之间滑动 - 在我的标签之间导航,我希望能够只触摸我想要导航到的标签.
在我的MainActivity中,我有:
public class MainActivity extends ActionBarActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TabLayout tabLayout = (TabLayout) findViewById(R.id.tab_layout);
tabLayout.addTab(tabLayout.newTab().setText("Newsfeed"));
tabLayout.addTab(tabLayout.newTab().setText("Random"));
tabLayout.setOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
@Override
public void onTabSelected(TabLayout.Tab tab) {
// IDEALLY HERE, I'd like to do something like
// tab.setFragment(new MainFragment()).
}
@Override
public void onTabUnselected(TabLayout.Tab tab) {
}
@Override
public void onTabReselected(TabLayout.Tab tab) {
}
});
}
所以我想覆盖我的onTabSelected和onTabReselected方法,以便在两个选项卡之间切换导致分别显示两个不同的片段.我在网上找不到很多关于独立于ViewPager的新TabLayout.
有线索吗？谢谢!
我知道可变结构是邪恶的.但是,我仍然想比较一个结构数组与一个对象数组的性能.这就是我到目前为止所拥有的
public struct HelloStruct
{
public int[] hello1;
public int[] hello2;
public int hello3;
public int hello4;
public byte[] hello5;
public byte[] hello6;
public string hello7;
public string hello8;
public string hello9;
public SomeOtherStruct[] hello10;
}
public struct SomeOtherStruct
{
public int yoyo;
public int yiggityyo;
}
public class HelloClass
{
public int[] hello1;
public int[] hello2;
public int hello3;
public int hello4;
public byte[] hello5;
public byte[] hello6;
public string hello7;
public string hello8;
public string hello9;
public SomeOtherClass[] …我有一个套接字，我在单个线程中接收和发送该套接字。然而，还有另一个线程可以定期使用套接字发送数据。目前，我正在使用共享对象来锁定我的Socket.send()操作。这个锁有必要吗？如果是，即使我只从一个线程接收数据，我是否也需要锁定我的接收方法？
例如在线程1中：
//...some code
while (offset< len)
{
currentBytesRead += Client.Receive(buf, offset, len - offset, SocketFlags.None);
}
//...some more code...
lock (lockObject)
{
Client.Send(outputByte);
}
在线程2中：
lock (lockObject)
{
Client.Send(outputByte);
}
我正在通过C#由Jeffrey Richter阅读CLR,在第115页上有一个由基元上的算术运算产生溢出的例子.有人可以解释一下吗？
Byte b = 100;
b = (Byte) (b+200); // b now contains 44 (or 2C in Hex).
我知道应该有溢出,因为byte是无符号的8位值,但为什么它的值等于44？
静态变量存储在非静态方法调用中的哪里？即内部CalculateTotalStatic(),我们正在递增静态成员MyStaticVariableHolder.Total,并且也比较变量i与MyStaticVariableHolder.TotalArray.Length内部的for循环.
另一方面,在此方法的另一个版本中CalculateTotalLocal(),我们使用在方法中声明的局部变量来执行上述操作.
在此期间CalculateTotalLocal,堆栈上将放置两个附加变量,这些变量将在堆栈本身(localTotal和localLength)上保存它们的值.在这种情况下会发生什么CalculateTotalStatic？它每次都从堆中访问静态变量吗？而且,CalculateTotalLocal比10%快CalculateTotalStatic.这种性能提升的正确原因是什么？
编辑 - 我想我不是很清楚 - 为此道歉.
我想说的是:
可以(根据C#规范)通过兼容的C#编译器/ JIT以与局部变量相同的方式优化静态变量访问？
class MyStaticVariableHolder
{
public static int[] TotalArray = new int[100];
public static int Total = 1;
}
class Trial
{
public void CalculateTotalStatic()
{
for (int i = 0; i < MyStaticVariableHolder.TotalArray.Length; i++)
{
MyStaticVariableHolder.Total += i;
}
}
public void CalculateTotalLocal()
{
int localTotal = MyStaticVariableHolder.Total; …我有一个结构数组，它是一个全局变量，其中一个结构成员是布尔值。特定 CPU 中的一个线程正在读取布尔值，不同 CPU 中的另一个线程可以通过将布尔值分配为 true 或 false ( my_array[index].bool = true/false)来定期更改布尔值。
我知道不使用任何形式的同步机制将导致未定义的行为。
但是，假设：
sizeof(bool)==1，我可以肯定地说，在上述条件下，我可以在不使用互斥锁等同步机制的情况下逃脱，并且没有未定义的行为吗？