List<T>.FindIndex 메서드

정의

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 List<T>이나 그 일부에서 처음으로 검색한 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the first occurrence within the List<T> or a portion of it. 이 메서드는 조건이 일치하는 항목이 없는 경우 -1을 반환합니다.This method returns -1 if an item that matches the conditions is not found.

오버로드

FindIndex(Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 전체 List<T>에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire List<T>.

FindIndex(Int32, Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 지정된 인덱스에서 마지막 요소로 확장하는 List<T>의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

FindIndex(Int32, Int32, Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 지정된 인덱스부터 시작하여 지정된 수의 요소를 포함하는 List<T>의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

FindIndex(Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 전체 List<T>에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire List<T>.

public:
 int FindIndex(Predicate<T> ^ match);
public int FindIndex (Predicate<T> match);
member this.FindIndex : Predicate<'T> -> int
Public Function FindIndex (match As Predicate(Of T)) As Integer

매개 변수

match
Predicate<T>

검색할 요소의 조건을 정의하는 Predicate<T> 대리자입니다.The Predicate<T> delegate that defines the conditions of the element to search for.

반환

match에 정의된 조건과 일치하는 요소가 있으면 일치하는 요소 중 첫 번째로 나타나는 요소의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

예외

matchnull인 경우match is null.

예제

다음 예제에서는 NameId라는 두 개의 필드를 사용 하 여 Employee 클래스를 정의 합니다.The following example defines an Employee class with two fields, Name and Id. 또한 Employee.Name 필드가 EmployeeSearch 클래스 생성자에 제공 되는 지정 된 부분 문자열로 시작 하는지 여부를 나타내는 단일 메서드인 StartsWith를 사용 하 여 EmployeeSearch 클래스를 정의 합니다.It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 이 메서드의 서명은 참고Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

FindIndex 메서드에 전달할 수 있는 대리자의 서명에 해당 합니다.corresponds to the signature of the delegate that can be passed to the FindIndex method. 이 예제에서는 List<Employee> 개체를 인스턴스화하고, 개체에 많은 Employee 개체를 추가한 다음, FindIndex(Int32, Int32, Predicate<T>) 메서드를 두 번 호출 하 여 Name 필드가 "J"로 시작 하는 첫 번째 Employee 개체에 대해 처음으로, Employee 필드가 "Ju"로 시작 하는 첫 번째 Name 개체의 두 번째 개체에 대해 전체 컬렉션을 검색 합니다.The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the entire collection, the first time for the first Employee object whose Name field begins with "J", and the second time for the first Employee object whose Name field begins with "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5
Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

설명

List<T>는 첫 번째 요소부터 시작 하 여 마지막 요소부터 끝까지 검색 됩니다.The List<T> is searched forward starting at the first element and ending at the last element.

Predicate<T>은 전달 된 개체가 대리자에 정의 된 조건과 일치 하는 경우 true를 반환 하는 메서드에 대 한 대리자입니다.The Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 현재 List<T>의 요소는 Predicate<T> 대리자에 개별적으로 전달 됩니다.The elements of the current List<T> are individually passed to the Predicate<T> delegate. 대리자에 서명을 합니다.The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

이 메서드는 선형 검색을 수행 합니다. 따라서이 메서드는 O (n) 작업입니다. 여기서 nCount입니다.This method performs a linear search; therefore, this method is an O(n) operation, where n is Count.

추가 정보

FindIndex(Int32, Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 지정된 인덱스에서 마지막 요소로 확장하는 List<T>의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

public:
 int FindIndex(int startIndex, Predicate<T> ^ match);
public int FindIndex (int startIndex, Predicate<T> match);
member this.FindIndex : int * Predicate<'T> -> int
Public Function FindIndex (startIndex As Integer, match As Predicate(Of T)) As Integer

매개 변수

startIndex
Int32

검색의 0부터 시작하는 인덱스입니다.The zero-based starting index of the search.

match
Predicate<T>

검색할 요소의 조건을 정의하는 Predicate<T> 대리자입니다.The Predicate<T> delegate that defines the conditions of the element to search for.

반환

match에 정의된 조건과 일치하는 요소가 있으면 일치하는 요소 중 첫 번째로 나타나는 요소의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

예외

matchnull인 경우match is null.

startIndexList<T>의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for the List<T>.

예제

다음 예제에서는 NameId라는 두 개의 필드를 사용 하 여 Employee 클래스를 정의 합니다.The following example defines an Employee class with two fields, Name and Id. 또한 Employee.Name 필드가 EmployeeSearch 클래스 생성자에 제공 되는 지정 된 부분 문자열로 시작 하는지 여부를 나타내는 단일 메서드인 StartsWith를 사용 하 여 EmployeeSearch 클래스를 정의 합니다.It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 이 메서드의 서명은 참고Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

FindIndex 메서드에 전달할 수 있는 대리자의 서명에 해당 합니다.corresponds to the signature of the delegate that can be passed to the FindIndex method. 예제에서는 List<Employee> 개체를 인스턴스화하고 여기에 Employee 개체를 추가한 다음 FindIndex(Int32, Int32, Predicate<T>) 메서드를 두 번 호출 하 여 다섯 번째 멤버 (인덱스 4의 멤버)로 시작 하는 컬렉션을 검색 합니다.The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the collection starting with its fifth member (that is, the member at index 4). 처음에는 Name 필드가 "J"로 시작 하는 첫 번째 Employee 개체를 검색 합니다. 두 번째로 Name 필드가 "Ju"로 시작 하는 첫 번째 Employee 개체를 검색 합니다.The first time, it searches for the first Employee object whose Name field begins with "J"; the second time, it searches for the first Employee object whose Name field begins with "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      int index = employees.FindIndex(4, es.StartsWith);        
      Console.WriteLine("Starting index of'J': {0}",
                        index >= 0 ? index.ToString() : "Not found");

      es = new EmployeeSearch("Ju");
      index = employees.FindIndex(4, es.StartsWith);        
      Console.WriteLine("Starting index of 'Ju': {0}",
                        index >= 0 ? index.ToString() : "Not found");
   }
}
// The example displays the following output:
//       'J' starts at index 4
//       'Ju' starts at index 5
Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Dim index As Integer = employees.FindIndex(4, AddressOf es.StartsWith)        
      Console.WriteLine("Starting index of'J': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

      es = New EmployeeSearch("Ju")
      index = employees.FindIndex(4, AddressOf es.StartsWith) 
      Console.WriteLine("Starting index of'Ju': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 4
'       'Ju' starts at index 5

설명

List<T>startIndex에서 시작 하 여 마지막 요소부터 끝까지 검색 됩니다.The List<T> is searched forward starting at startIndex and ending at the last element.

Predicate<T>은 전달 된 개체가 대리자에 정의 된 조건과 일치 하는 경우 true를 반환 하는 메서드에 대 한 대리자입니다.The Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 현재 List<T>의 요소는 Predicate<T> 대리자에 개별적으로 전달 됩니다.The elements of the current List<T> are individually passed to the Predicate<T> delegate. 대리자에 서명을 합니다.The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

이 메서드는 선형 검색을 수행 합니다. 따라서이 메서드는 O (n) 작업입니다. 여기서 nstartIndex에서 List<T>끝 까지의 요소 수입니다.This method performs a linear search; therefore, this method is an O(n) operation, where n is the number of elements from startIndex to the end of the List<T>.

추가 정보

FindIndex(Int32, Int32, Predicate<T>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 지정된 인덱스부터 시작하여 지정된 수의 요소를 포함하는 List<T>의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

public:
 int FindIndex(int startIndex, int count, Predicate<T> ^ match);
public int FindIndex (int startIndex, int count, Predicate<T> match);
member this.FindIndex : int * int * Predicate<'T> -> int
Public Function FindIndex (startIndex As Integer, count As Integer, match As Predicate(Of T)) As Integer

매개 변수

startIndex
Int32

검색의 0부터 시작하는 인덱스입니다.The zero-based starting index of the search.

count
Int32

검색할 섹션에 있는 요소 수입니다.The number of elements in the section to search.

match
Predicate<T>

검색할 요소의 조건을 정의하는 Predicate<T> 대리자입니다.The Predicate<T> delegate that defines the conditions of the element to search for.

반환

match에 정의된 조건과 일치하는 요소가 있으면 일치하는 요소 중 첫 번째로 나타나는 요소의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

예외

matchnull인 경우match is null.

startIndexList<T>의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for the List<T>.

-또는--or- count가 0보다 작습니다.count is less than 0.

-또는--or- startIndexcountList<T>의 올바른 섹션을 지정하지 않습니다.startIndex and count do not specify a valid section in the List<T>.

예제

다음 예제에서는 NameId라는 두 개의 필드를 사용 하 여 Employee 클래스를 정의 합니다.The following example defines an Employee class with two fields, Name and Id. 또한 Employee.Name 필드가 EmployeeSearch 클래스 생성자에 제공 되는 지정 된 부분 문자열로 시작 하는지 여부를 나타내는 단일 메서드인 StartsWith를 사용 하 여 EmployeeSearch 클래스를 정의 합니다.It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 이 메서드의 서명은 참고Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

FindIndex 메서드에 전달할 수 있는 대리자의 서명에 해당 합니다.corresponds to the signature of the delegate that can be passed to the FindIndex method. 이 예제에서는 List<Employee> 개체를 인스턴스화하고 여기에 많은 Employee 개체를 추가한 다음 FindIndex(Int32, Int32, Predicate<T>) 메서드를 두 번 호출 하 여 전체 컬렉션 (즉, 인덱스 0부터 인덱스 Count-1)을 검색 합니다.The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the entire collection (that is, the members from index 0 to index Count - 1). 처음에는 Name 필드가 "J"로 시작 하는 첫 번째 Employee 개체를 검색 합니다. 두 번째로 Name 필드가 "Ju"로 시작 하는 첫 번째 Employee 개체를 검색 합니다.The first time, it searches for the first Employee object whose Name field begins with "J"; the second time, it searches for the first Employee object whose Name field begins with "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1, es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5
Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

설명

List<T>startIndex부터 앞으로 검색 하 여 count startIndex에 종료 하 고 count가 0 보다 큰 경우에는 1을 뺀 값입니다.The List<T> is searched forward starting at startIndex and ending at startIndex plus count minus 1, if count is greater than 0.

Predicate<T>은 전달 된 개체가 대리자에 정의 된 조건과 일치 하는 경우 true를 반환 하는 메서드에 대 한 대리자입니다.The Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 현재 List<T>의 요소는 Predicate<T> 대리자에 개별적으로 전달 됩니다.The elements of the current List<T> are individually passed to the Predicate<T> delegate. 대리자에 서명을 합니다.The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

이 메서드는 선형 검색을 수행 합니다. 따라서이 메서드는 O (n) 작업입니다. 여기서 ncount입니다.This method performs a linear search; therefore, this method is an O(n) operation, where n is count.

추가 정보

적용 대상