Reprise du message précédent :
voilà

 
Ceci est une déclaration de constructeur. Que signifie Class<?> ?

en fait c'est pour lier le type statique et le type dynamique. quand tu n'as pas le type statique, tu mets "?" .
 
je te donne un exemple avec le type statique dans 5s ...

 
Time is up!

 
et ça s'utilise comme ça :

 
et je peux pas mettre un truc différent entre les "<>" et le  le Machin.class, sinon c'est statiquement pas valide.
 
la grosse feinte c'est qu'on a pas le droit d'instancier les paramètres directement ( par exemple new T[10] est interdit) donc on est obligé de passer la classe en paramètre (avec la classe on peut faire un Array.newInstance()) . Mais ça ouvre la porte à une vulnérabilité : passer une classe qui ne correspond pas au paramètre de type.
 
Avec cette feinte, on peut pas passer une classe qui a un type différent du paramètre .

enfin, la réponse de base, c'est juste que la classe Class est paramétrée en java 5 et que le mec se foutait du paramètre (comme dans la plupart des cas).

grmf, dans une regex, comment je peux faire "tout sauf ::"
 
[^:]* pour "tout sauf : " mais la jvois pas

arrête les regexes  
 
'tain, c'est fini la maternelle

sans avoir testé [^(::)]* ?

grammaires
1956 is over.

depuis quqnd on peut faire des groupes dans des classes?

 
 
bidouilles de chaines de caratères  
1956 is over.
 
 
on utilise des objets maintenant.

pas con comme remarque... ça m'était sorti comme ça...

ha ben c'est surtout qu'qvec un du texte en entrée, chuis pas obligé de triturer du texte hein ?
(a ton avis, keske j'en fait, une fois que le texte est passé dans la regex )

Les assertions avant, c'est pas (?:blablabla) ?

hein ??

Ce sont des contraintes sur les caractères entourant ton caractère (tu prends tout sauf les ":", ou bien alors n'importe quel ":" sauf s'il est suivi ou précédé de ":", mais tu veux juste tester les caractères entourant l'actuel pas les consommer), donc il faut faire appel aux look* assertions (negative lookbehind assertion et negative lookahead assertion ici)

À noter que ça élimine aussi les ":::", mais que ça devrait accepter les ":" seuls en début ou fin de string/ligne

Bin y'a plusieurs sortes de "tout sauf".
Avec des caractères, on utilise [^ ], mais s'il s'agit de "tout sauf le mot groseille", il faut une assertion avant.

Par exemple, "tout sauf groseille", c'est (?!groseille) mais je sais plus exactement ni comment ça fonctionne, ni comment c'est implémenté en Java

Edit: bon bin Mesquine a mieux expliqué que moi

peut-être que c'est pas du plain text mais du texte décoré que tu manipules

J'vois pas ce que ça a de maternel les regex, si ma mère était comme ça je me serais barré depuis longtemps

oui enfin mtnt que j'ai ton exemple, je vais relire ce qu'il q dit

 
C'est pas bientôt fini de décorer le texte ?
'tain, c'est fini la maternelle

uh, on s'approche, mais:

doivent me permettre de recuperer
 "pouet" et "truc"  
ou
 null et "pouet"
ou
 null et null
 

heuuu dis moi, t'as pas songé à splitter sur "::" tout simplement?

nan, parce qu'évidement, il a une grammaire plus compliquée et qu'il veut pas utiliser les outils adaptés

Donc tu nous dit pas tout, parce que bon sur ton exemple à toi ça fonctionne très bien:

def getStupidStuff(s):
    def lpad(lst):
        if len(lst) == 2: return lst
        elif len(lst) == 1: return [None] + lst
        else: return [None, None]
    return lpad(filter(lambda s: len(s) > 0, s.split("::" )[-2:]))

j4oubliais les quotes :

doivent me permettre de recuperer
 "pouet" et "truc"  
ou
 null et "pouet"
ou
 null et null
 

 
 
nraynaud : vachement convaincant

def getStupidStuff(s):
    def lpad(lst):
        if len(lst) == 2: return lst
        elif len(lst) == 1: return [None] + lst
        else: return [None, None]
    return lpad(filter(lambda s: len(s) > 0, s.split("::" )[-2:]))

 
C'est joliiii

def getStupidStuff(s):
    def lpad(lst):
        if len(lst) == 2: return lst
        elif len(lst) == 1: return [None] + lst
        else: return [None, None]
    return lpad(filter(lambda s: len(s) > 0, s.split("::" )[-2:]))

heu j'habite de l'autre côté des toblerones et je suis pas gros moi

Ptin mais franchement va faloir que t'arrêtes de faire du Java d'urgence toi

def getStupidStuff(s):
    def lpad(lst):
        if len(lst) == 2: return lst
        elif len(lst) == 1: return [None] + lst
        else: return [None, None]
    return lpad(
        map(lambda s: s.strip('\''),
            filter(lambda s: len(s) > 0,
                s.split("::" )[-2:]))) # cette expression vous est offerte par "Oui, je peux aussi faire du Lisp en Python"

et haupe

On se moque pas, c'est fait pour être jeté pas maintenu donc ça a pas besoin d'être lisible

D'ailleurs c'est probablement faisable en une seule ligne de Perl

daÿsolaÿ

ouais, sauf qu'avec les groupes de la regex, j'avais un joli mapping facile a faire entre une regex et des attributs d'un objet

ouais, mais non

genre c'est dur à faire, deux affectations

Bon ok t'es en java et tu peux pas pêter un coup sans faire un rapport en 3 exemplaires au compilo, mais quand même

il dit qu'il voit pas le rapport, et que vous êtes prié de brancher le cerveau, merci

ah ah lol

Tiche TUC !!! BAAAM!
FATAL ERROR !!!  

g fait un truc bizarre alors

 
kitétoua ?  

lol excusez moi je flood.
Gourde comme je suis.
Trompé de topic.

quel serait selon vous le meilleur moyen de verifier l'integrité d'un fichier (ou d'un tas de fichiers, plus precisement....) sur le filesystem? ... Sachant que j'ai plus besoin de perfs que de sûreté, pour autant que le systeme ne me sorte pas de faux négatifs, of course.

Les fichiers existent déjà ou tu veux créer des fichiers dont tu pourras vérifier l'intégrité par la suite?

euh, les 2 mon général; pourquoi cette question ?
(en gros, j'extrait des fichiers d'une archive et je veux verifier que l'user a pas fait le malin en les modifiant)