小编Rad*_*def的帖子

我有一个字节变量:

byte varB = (byte) -1; // binary view: 1111 1111

我想看到两个最左边的位并执行6位无符号右移:

varB = (byte) (varB >>> 6);

但是我得到的-1好像是int类型,只有当我换30时才得到3!

我该如何解决这个问题,只能通过6位移位获得结果？

如何在流畅验证中按实体类型注入或查找验证器？我有以下课程并希望通过流畅的验证来验证实体

    public class BaseEntity {}

    public class Article :BaseEntity
    {
         public string Name {get;set;}
    }

    public class ArticleValidator : AbstractValidator<Article>
    {
         public ArticleValidator()
         {
              RuleFor(x => x.Name ).NotEmpty().Length(0,512);
         }
    }

并有 BaseEntity 的扩展：

    public static ValidationResult Validate(this BaseEntity entity)
    {
        //????and here how i can find entity validator by type of entity  and  validate it and return result.
    }

    public class ArticleService
    {
         public void AddArticle(Article aricle)
         {
             var result = article.Validate();
             if(result.IsValid)
                 ;.......
         }
    } 

我有一个相对简单的问题,我试图解决.似乎没有直观的方法来做到这一点,或者我在这里遗漏了一些东西.

考虑使用此方法查找主图像,如果不存在,则返回第一张图像 -

public Image findMainImage(Collection<? extends Image> images) {
    if (images == null || images.isEmpty()) return null
    return images.stream()
                 .filter(Image::isMain)
                 .findFirst()
                 .orElse(images.iterator().next())
}

我收到一个错误 - orElse(capture<? extends Image>) in Optional cannot be applied

任何方向都会很棒.

尝试为通用链表创建迭代器.当我尝试创建一个"当前"节点以便根据头部标记迭代列表时,我得到一个不兼容的类型错误.这是重要的线条

public class LinkedList<T> implements Iterable<T>
{
    private node<T> headsent;
    private node<T> tailsent; 
    public DistanceEventList()
    {
        headsent = new node<T>();
        tailsent = new node<T>();
        headsent.setnext(tailsent);
        tailsent.setprevious(headsent);
    }
    public node<T> getheadsent()
    {
        return headsent;
    }
    ...
    public MyIterator<T> iterator() {
        return new MyIterator<T>();
    }
    public class MyIterator<T> implements Iterator<T>
    {
        private node<T> current = getheadsent();
        public T next() {
            current = current.getnext();
            return current.getdata();
        }
    private class node<T> {
        private T data;
        private node<T> next;
        private node<T> previous;    
        ...
        public node<T> …

在List通过返回Arrays.asList不能通过使用方法如被修改add或remove.但是如果你将它传递给Collections.sort方法,它可以毫无问题地对数组进行排序(我预计会有例外).这似乎是一种非常不一致的行为.那么方法List返回的允许操作是什么asList？

List<Integer> list = Arrays.asList(5,7, 10 , 8,9);
list.remove(2);//Exception

Collections.sort(list);//Ok, No Exception Sort...
System.out.println(list);

我在文档中找不到任何线索.

编辑:是的我可以理解为什么它不支持remove或add.但那么它如何支持排序呢？

我想在我的GUI中使用透明面板(如果像Windows 7窗口标题一样,那就更好了).

之前我用com.sun.awt.AWTUtilities的

AWTUtilities.setWindowOpacity(frame, (float)0.90);

但它的参数是一个窗口JFrame,不能用于JPanel.

此外,我希望在Windows 7标题按钮上具有效果JPanel或JLabel例如发光效果.任何其他有趣的效果对我也有帮助.

我写了一个代码来读取WAV文件(大小约为80 MB)并播放它.问题是声音播放严重(极端滞后).你能告诉我这是什么问题吗？

这是我的代码:(我doPlay在Jframe构造函数中调用函数)

private void doPlay(final String path) {
    try {
        stopPlay();
        InputStream is = new FileInputStream(path);
        InputStream bufferedIn = new BufferedInputStream(is);
        AudioInputStream ais = AudioSystem.getAudioInputStream(bufferedIn);
        AudioFormat format = ais.getFormat();
        // this is the value of format.
        // PCM_SIGNED 44100.0 Hz, 16 bit, stereo, 4 bytes/frame, little-endian
        DataLine.Info info = new DataLine.Info(Clip.class, format);
        clip = (Clip)AudioSystem.getLine(info);
        clip.open(ais);
        clip.start();
    } catch (Exception e) {
        stopPlay();
        e.printStackTrace();
    }
}

我有一些像这样的代码:

@SuppressWarnings({"unchecked", "rawtypes"})
List<String> theList = new ArrayList();

这种类型安全吗？我认为这是安全的,因为我没有将原始类型分配给其他任何东西.我甚至可以证明它在我打电话时执行类型检查add:

theList.add(601); // compilation error

我读过"什么是原始类型,我们为什么不使用它？" 但我认为它不适用于此,因为我只使用原始类型创建列表.之后,我将其分配给参数化类型,那么可能出现什么问题？

还有,这个怎么样？

@SuppressWarnings({"unchecked", "rawtypes"})
List<String> anotherList = new ArrayList(theList);

我会保持简短,我有一个Dog类如下:

public class Dog 
{
   public void Foo() 
   { 
      System.out.println("Right Call");
   }

   public void Boo()
   {
     System.out.println("Wrong Call");
   }
}

和以下主要方法:

HashMap<String, Method> map = new HashMap<String, Method>();

Dog d = new Dog();

Method[] method = d.getClass().getMethods();

map.put("foo", method[0]);

Method a = map.get("foo");

try {
    a.invoke(d, null);
} catch (IllegalAccessException | IllegalArgumentException
        | InvocationTargetException e) {
    e.printStackTrace();
}

每当我再次运行它时,它只是任意给出Right Call或Wrong Call输出.

我需要确保每次放置"foo"密钥时,都必须调用Foo()方法,而不是Boo().

显然,它并没有缓解我的"方法调用"问题.我怎样才能克服这个问题？我每次都必须调用正确的方法.我对这些反思很新,有什么我不应该做的,或者我做错了什么？或者有更好的方法来实现此方法调用？

编辑:我也试过LinkedHashMap,但结果是一样的.

谢谢.

如果我有一个集合,我想迭代一个过滤流,那么我可以做以下任何一个(以及更多的钝选项):

for(item in collection.stream().filter(...).collect(Collectors.toList()))
for(item in collection.stream().filter(...).collect(Collectors.toSet()))

哪个更快？一个列表还是一组？有没有办法收集简单的Iterable或其他类型我可以迭代？